working cache

backend/src/overpass/overpass.py

@@ -0,0 +1,114 @@
+from typing import Literal, List
+import urllib
+import json
+import xml.etree.ElementTree as ET
+
+from .caching_strategy import get_cache_key, CachingStrategy
+
+
+ElementTypes = List[Literal['way', 'node', 'relation']]
+
+
+def build_query(area: tuple, element_types: ElementTypes, selector: str, 
+                         conditions=[], out='center'):
+    """
+    Constructs a query string for the Overpass API to retrieve OpenStreetMap (OSM) data.
+
+    Args:
+        area (tuple): A tuple representing the geographical search area, typically in the format 
+                      (radius, latitude, longitude). The first element is a string like "around:2000" 
+                      specifying the search radius, and the second and third elements represent 
+                      the latitude and longitude as floats or strings.
+        element_types (list[str]): A list of OSM element types to search for. Must be one or more of 
+                                   'Way', 'Node', or 'Relation'.
+        selector (str): The key or tag to filter the OSM elements (e.g., 'amenity', 'highway', etc.).
+        conditions (list, optional): A list of conditions to apply as additional filters for the 
+                                     selected OSM elements. The conditions should be written in 
+                                     the Overpass QL format, and they are combined with '&&' if 
+                                     multiple are provided. Defaults to an empty list.
+        out (str, optional): Specifies the output type, such as 'center', 'body', or 'tags'. 
+                             Defaults to 'center'.
+
+    Returns:
+        str: The constructed Overpass QL query string.
+
+    Notes:
+        - If no conditions are provided, the query will just use the `selector` to filter the OSM 
+          elements without additional constraints.
+        - The search area must always formatted as "(radius, lat, lon)".
+    """
+    if not isinstance(conditions, list) :
+        conditions = [conditions]
+
+    query = '('
+
+    # Round the radius to nearest 50 and coordinates to generate less queries
+    search_radius = round(area[0] / 50) * 50
+    loc = tuple((round(area[1], 2), round(area[2], 2)))
+    search_area = f"(around:{search_radius}, {str(loc[0])}, {str(loc[1])})"
+
+    if conditions :
+        conditions = '(if: ' + ' && '.join(conditions) + ')'
+    else :
+        conditions = ''
+
+    for elem in element_types :
+        query += elem + '[' + selector + ']' + conditions + search_area + ';'
+
+    query += ');' + f'out {out};'
+
+    return query
+
+
+def send_overpass_query(query: str, use_cache: bool = True) -> dict:
+    """
+    Sends the Overpass QL query to the Overpass API and returns the parsed JSON response.
+
+    Args:
+        query (str): The Overpass QL query to be sent to the Overpass API.
+
+    Returns:
+        dict: The parsed JSON response from the Overpass API, or None if the request fails.
+    """
+
+    # Generate a cache key for the current query
+    cache_key = get_cache_key(query)
+
+    # Try to fetch the result from the cache
+    cached_response = CachingStrategy.get(cache_key)
+    if cached_response:
+        print("Cache hit!")
+        return cached_response
+
+    # Define the Overpass API endpoint
+    overpass_url = "https://overpass-api.de/api/interpreter"
+
+    # Prepare the data to be sent as POST request, encoded as bytes
+    data = urllib.parse.urlencode({'data': query}).encode('utf-8')
+
+    # Create a custom header with a User-Agent
+    headers = {
+        'User-Agent': 'Mozilla/5.0 (compatible; OverpassQuery/1.0; +http://example.com)',
+    }
+
+    try:
+        # Create a Request object with the specified URL, data, and headers
+        request = urllib.request.Request(overpass_url, data=data, headers=headers)
+        
+        # Send the request and read the response
+        with urllib.request.urlopen(request) as response:
+            # Read and decode the response
+            response_data = response.read().decode('utf-8')
+            root = ET.fromstring(response_data)
+
+            # Cache the response data as an ElementTree root
+            CachingStrategy.set(cache_key, root)
+
+            return root
+
+    except urllib.error.URLError as e:
+        print(f"Error connecting to Overpass API: {e}")
+        return None
+    except json.JSONDecodeError:
+        print("Error decoding the JSON response from Overpass API.")
+        return None