Add auto filter code based on flags

Author: ScrappyCocco

howlongtobeatpy/howlongtobeatpy/HowLongToBeat.py

@@ -20,12 +20,14 @@ class HowLongToBeat:
     # Constructor with optional parameters
     # ------------------------------------------
 
-    def __init__(self, input_minimum_similarity: float = 0.4):
+    def __init__(self, input_minimum_similarity: float = 0.4, input_auto_filter_times: bool = False):
         """
         @param input_minimum_similarity: Minimum similarity to use to filter the results with the found name,
+        @param input_auto_filter_times: If the json parser should automatically filter times based on the game types (online/sp)
         0 will return all the results; 1 means perfectly equal and should not be used; default is 0.4;
         """
         self.minimum_similarity = input_minimum_similarity
+        self.auto_filter_times = input_auto_filter_times
 
         if platform.system() == 'Windows':
             asyncio.set_event_loop_policy(asyncio.WindowsSelectorEventLoopPolicy())
@@ -126,11 +128,11 @@ def __parse_web_result(self, game_name: str, html_result, game_id=None,
         """
         if game_id is None:
             parser = JSONResultParser(game_name, HTMLRequests.GAME_URL, self.minimum_similarity, game_id,
-                                      similarity_case_sensitive)
+                                      similarity_case_sensitive, self.auto_filter_times)
         else:
             # If the search is by id, ignore class minimum_similarity and set it to 0.0
             # The result is filtered by ID anyway, so the similarity shouldn't count too much
             # Also ignore similarity_case_sensitive and leave default value
-            parser = JSONResultParser(game_name, HTMLRequests.GAME_URL, 0.0, game_id)
+            parser = JSONResultParser(game_name, HTMLRequests.GAME_URL, 0.0, game_id, False, self.auto_filter_times)
         parser.parse_json_result(html_result)
         return parser.results

howlongtobeatpy/howlongtobeatpy/HowLongToBeatEntry.py

@@ -43,3 +43,13 @@ def __init__(self):
         self.completionist = None
         # All styles
         self.all_styles = None
+        # invested_co value
+        self.coop_time = None
+        # invested_mp value
+        self.mp_time = None
+        # These are used to identify if the game has singpe, coop and/or multiplayer
+        # So you can filter data based on those
+        self.complexity_lvl_combine = False
+        self.complexity_lvl_sp = False
+        self.complexity_lvl_co = False
+        self.complexity_lvl_mp = False

howlongtobeatpy/howlongtobeatpy/JSONResultParser.py

@@ -20,11 +20,13 @@ class JSONResultParser:
 
     def __init__(self, input_game_name: str, input_game_url: str,
                  input_minimum_similarity: float, input_game_id: int = None,
-                 input_similarity_case_sensitive: bool = True):
+                 input_similarity_case_sensitive: bool = True,
+                 input_auto_filter_times: bool = False):
         # Init instance variables
         self.results = []
         self.minimum_similarity = input_minimum_similarity
         self.similarity_case_sensitive = input_similarity_case_sensitive
+        self.auto_filter_times = input_auto_filter_times
         self.game_id = input_game_id
         self.base_game_url = input_game_url
         # Init object
@@ -75,6 +77,21 @@ def parse_json_element(self, input_game_element):
             current_entry.completionist = round(input_game_element.get("comp_100") / 3600, 2)
         if "comp_all" in input_game_element:
             current_entry.all_styles = round(input_game_element.get("comp_all") / 3600, 2)
+        if "invested_co" in input_game_element:
+            current_entry.coop_time = round(input_game_element.get("invested_co") / 3600, 2)
+        if "invested_mp" in input_game_element:
+            current_entry.mp_time = round(input_game_element.get("invested_mp") / 3600, 2)
+        # Add complexity booleans
+        current_entry.complexity_lvl_combine = bool(input_game_element.get("comp_lvl_combine", 0))
+        current_entry.complexity_lvl_sp = bool(input_game_element.get("comp_lvl_sp", 0))
+        current_entry.complexity_lvl_co = bool(input_game_element.get("comp_lvl_co", 0))
+        current_entry.complexity_lvl_mp = bool(input_game_element.get("comp_lvl_mp", 0))
+        if self.auto_filter_times:
+            # Auto-Nullify values based on the flags
+            if current_entry.complexity_lvl_co is False:
+                current_entry.coop_time = None
+            if current_entry.complexity_lvl_mp is False:
+                current_entry.mp_time = None
         # Compute Similarity
         game_name_similarity = self.similar(self.game_name, current_entry.game_name,
                                             self.game_name_numbers, self.similarity_case_sensitive)

howlongtobeatpy/setup.py

@@ -4,7 +4,7 @@
     long_description = fh.read()
 
 setup(name='howlongtobeatpy',
-      version='1.0.17',
+      version='1.0.18',
       packages=find_packages(exclude=['tests']),
       description='A Python API for How Long to Beat',
       long_description=long_description,

howlongtobeatpy/tests/test_async_request.py

@@ -42,6 +42,15 @@ async def test_game_name_with_numbers(self):
         self.assertEqual("The Witcher 3: Wild Hunt", best_result.game_name)
         self.assertAlmostEqual(50, TestNormalRequest.getSimpleNumber(best_result.main_story), delta=25)
 
+    @async_test
+    async def test_game_with_auto_filter(self):
+        results = await HowLongToBeat(input_auto_filter_times = True).async_search("The Witcher 3")
+        self.assertNotEqual(None, results, "Search Results are None")
+        best_result = TestNormalRequest.getMaxSimilarityElement(results)
+        self.assertEqual("The Witcher 3: Wild Hunt", best_result.game_name)
+        self.assertEqual(None, best_result.coop_time)
+        self.assertEqual(None, best_result.mp_time)
+
     @async_test
     async def test_game_with_values(self):
         results = await HowLongToBeat().async_search("Crysis 3")

howlongtobeatpy/tests/test_async_request_by_id.py

@@ -36,6 +36,14 @@ async def test_game_name_with_numbers(self):
         self.assertEqual("The Witcher 3: Wild Hunt", result.game_name)
         self.assertAlmostEqual(50, TestNormalRequest.getSimpleNumber(result.main_story), delta=25)
 
+    @async_test
+    async def test_game_with_auto_filter(self):
+        result = await HowLongToBeat(input_auto_filter_times = True).async_search_from_id(10270)
+        self.assertNotEqual(None, result, "Search Result is None")
+        self.assertEqual("The Witcher 3: Wild Hunt", result.game_name)
+        self.assertEqual(None, result.coop_time)
+        self.assertEqual(None, result.mp_time)
+
     @async_test
     async def test_game_with_values(self):
         result = await HowLongToBeat().async_search_from_id(2070)

howlongtobeatpy/tests/test_normal_request.py

@@ -58,6 +58,15 @@ def test_game_name_with_numbers(self):
         self.assertEqual("The Witcher 3: Wild Hunt", best_result.game_name)
         self.assertAlmostEqual(50, self.getSimpleNumber(best_result.main_story), delta=5)
 
+    def test_game_with_auto_filter(self):
+        results = HowLongToBeat(input_auto_filter_times = True).search("The Witcher 3")
+        self.assertNotEqual(None, results, "Search Results are None")
+        best_result = self.getMaxSimilarityElement(results)
+        self.assertEqual("The Witcher 3: Wild Hunt", best_result.game_name)
+        self.assertAlmostEqual(50, self.getSimpleNumber(best_result.main_story), delta=5)
+        self.assertEqual(None, best_result.coop_time)
+        self.assertEqual(None, best_result.mp_time)
+
     def test_game_with_values(self):
         results = HowLongToBeat().search("Battlefield 2142")
         self.assertNotEqual(None, results, "Search Results are None")

howlongtobeatpy/tests/test_normal_request_by_id.py

@@ -31,6 +31,13 @@ def test_game_name_with_numbers(self):
         self.assertEqual("The Witcher 3: Wild Hunt", result.game_name)
         self.assertAlmostEqual(50, TestNormalRequest.getSimpleNumber(result.main_story), delta=5)
 
+    def test_game_with_auto_filter(self):
+        result = HowLongToBeat(input_auto_filter_times = True).search_from_id(10270)
+        self.assertNotEqual(None, result, "Search Result is None")
+        self.assertEqual("The Witcher 3: Wild Hunt", result.game_name)
+        self.assertEqual(None, result.coop_time)
+        self.assertEqual(None, result.mp_time)
+
     def test_game_with_values(self):
         result = HowLongToBeat().search_from_id(936)
         self.assertNotEqual(None, result, "Search Result is None")

sonar-project.properties

@@ -2,7 +2,7 @@ sonar.organization=scrappycocco-github
 sonar.projectKey=ScrappyCocco_HowLongToBeat-PythonAPI
 
 sonar.projectName=HowLongToBeat-PythonAPI
-sonar.projectVersion=1.0.17
+sonar.projectVersion=1.0.18
 sonar.python.version=3.9
 
 # Define separate root directories for sources and tests