first homemade OSM

backend/src/utils/landmarks_manager.py

@@ -1,13 +1,12 @@
 """Module used to import data from OSM and arrange them in categories."""
 import logging
 import yaml
-from OSMPythonTools.overpass import Overpass, overpassQueryBuilder
-from OSMPythonTools.cachingStrategy import CachingStrategy, JSON
 
 from ..structs.preferences import Preferences
 from ..structs.landmark import Landmark
 from .take_most_important import take_most_important
 from .cluster_manager import ClusterManager
+from .overpass import OverpassQueryBuilder, send_overpass_query, parse_result
 
 from ..constants import AMENITY_SELECTORS_PATH, LANDMARK_PARAMETERS_PATH, OPTIMIZER_PARAMETERS_PATH, OSM_CACHE_DIR
 
@@ -54,8 +53,8 @@ class LandmarkManager:
             self.walking_speed = parameters['average_walking_speed']
             self.detour_factor = parameters['detour_factor']
 
-        self.overpass = Overpass()
-        CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
+        # self.overpass = Overpass()
+        # CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
 
         self.logger.info('LandmakManager successfully initialized.')
 
@@ -78,13 +77,13 @@ class LandmarkManager:
         - A list of the most important landmarks based on the user's preferences.
         """
         self.logger.debug('Starting to fetch landmarks...')
-        max_walk_dist = (preferences.max_time_minute/2)/60*self.walking_speed*1000/self.detour_factor
+        max_walk_dist = int((preferences.max_time_minute/2)/60*self.walking_speed*1000/self.detour_factor)
         reachable_bbox_side = min(max_walk_dist, self.max_bbox_side)
 
         # use set to avoid duplicates, this requires some __methods__ to be set in Landmark
         all_landmarks = set()
 
-        # Create a bbox using the around technique
+        # Create a bbox using the around technique, tuple of strings
         bbox = tuple((f"around:{min(2000, reachable_bbox_side/2)}", str(center_coordinates[0]), str(center_coordinates[1])))
 
         # list for sightseeing
@@ -134,7 +133,21 @@ class LandmarkManager:
 
         return all_landmarks, landmarks_constrained
 
+    def set_score(self, landmark: Landmark, landmarktype: str, preference_level: int) :
 
+        score = landmark.n_tags**self.tag_exponent
+        if landmark.wiki_url :
+            score *= self.wikipedia_bonus
+        if landmark.image_url :
+            score *= self.image_bonus
+        if landmark.website_url :
+            score *= self.wikipedia_bonus
+        if landmark.is_place_of_worship :
+            score *= self.church_coeff
+
+        landmark.attractiveness = int(score * preference_level)
+
+    '''
     def fetch_landmarks(self, bbox: tuple, amenity_selector: dict, landmarktype: str, score_function: callable) -> list[Landmark]:
         """
         Fetches landmarks of a specified type from OpenStreetMap (OSM) within a bounding box centered on given coordinates.
@@ -170,15 +183,11 @@ class LandmarkManager:
                 query_conditions = []
                 element_types.append('node')
 
-            query = overpassQueryBuilder(
-                bbox = bbox,
-                elementType = element_types,
-                # selector can in principle be a list already,
-                # but it generates the intersection of the queries
-                # we want the union
+            query = OverpassQueryBuilder(
+                area = bbox,
+                element_types = element_types,
                 selector = sel,
                 conditions = query_conditions,        # except for nature....
-                includeCenter = True,
                 out = 'center'
                 )
             self.logger.debug(f"Query: {query}")
@@ -295,7 +304,63 @@ class LandmarkManager:
         self.logger.debug(f"Fetched {len(return_list)} landmarks of type {landmarktype} in {bbox}")
 
         return return_list
+    '''
 
+    def fetch_landmarks(self, bbox: tuple, amenity_selector: dict, landmarktype: str, score_function: callable) -> list[Landmark]:
+        """
+        Fetches landmarks of a specified type from OpenStreetMap (OSM) within a bounding box centered on given coordinates.
+
+        Args:
+            bbox (tuple[float, float, float, float]): The bounding box coordinates (around:radius, center_lat, center_lon).
+            amenity_selector (dict): The Overpass API query selector for the desired landmark type. 
+            landmarktype (str): The type of the landmark (e.g., 'sightseeing', 'nature', 'shopping').
+            score_function (callable): The function to compute the score of the landmark based on its attributes.
+
+        Returns:
+            list[Landmark]: A list of Landmark objects that were fetched and filtered based on the provided criteria.
+
+        Notes:
+            - Landmarks are fetched using Overpass API queries.
+            - Selectors are translated from the dictionary to the Overpass query format. (e.g., 'amenity'='place_of_worship')
+            - Landmarks are filtered based on various conditions including tags and type.
+            - Scores are assigned to landmarks based on their attributes and surrounding elements.
+        """
+        return_list = []
+
+        if landmarktype == 'nature' : query_conditions = []
+        else : query_conditions = ['count_tags()>5']
+
+        # caution, when applying a list of selectors, overpass will search for elements that match ALL selectors simultaneously
+        # we need to split the selectors into separate queries and merge the results
+        for sel in dict_to_selector_list(amenity_selector):
+            # self.logger.debug(f"Current selector: {sel}")
+
+            element_types = ['way', 'relation']
+
+            if 'viewpoint' in sel :
+                query_conditions = []
+                element_types.append('node')
+
+            query = OverpassQueryBuilder(
+                area = bbox,
+                element_types = element_types,
+                selector = sel,
+                conditions = query_conditions,        # except for nature....
+                out = 'center'
+                )
+            self.logger.debug(f"Query: {query}")
+
+            try:
+                result = send_overpass_query(query)
+            except Exception as e:
+                self.logger.error(f"Error fetching landmarks: {e}")
+                continue
+                
+            return_list = parse_result(result, landmarktype)
+
+        self.logger.debug(f"Fetched {len(return_list)} landmarks of type {landmarktype} in {bbox}")
+
+        return return_list
 
 def dict_to_selector_list(d: dict) -> list:
     """