Task 4: logging, new modul queries

main.py

@@ -1,11 +1,19 @@
+from main_start import QUERY
+from overpass import fetch_overpass
 import requests
-from pprint import pprint
 
 
-OVERPASS_URL = "https://overpass-api.de/api/interpreter"
+# ---------------------------------------------------------------------------
+# Konfiguration
+# ---------------------------------------------------------------------------
 
-BERGBAHN_QUERY = """
+BBOXEN = {
-[out:json][timeout:3][maxsize:500000];
+    "davos":    (46.72, 9.70,  46.92, 10.00),
+    "schweiz":  (45.8,  5.9,   47.8,  10.5),
+}
+
+QUERY  = """
+    [out:json][timeout:2][maxsize:500000];
     (
       node["aerialway"="station"]({bbox});
       way["aerialway"="station"]({bbox});
@@ -17,92 +25,48 @@ out center body;
     """
 
 
-def fetch_bergbahnen(bbox: tuple) -> dict:
+# ---------------------------------------------------------------------------
-    """
+# Hauptlogik
-        Fragt die Overpass API nach Bergbahnen in der angegebenen Bounding Box ab.
+# ---------------------------------------------------------------------------
+def main() -> None:
 
-        Sendet einen HTTP-POST-Request an die Overpass API und gibt die geparste
+    for name, bbox in BBOXEN.items():
-        JSON-Antwort zurück. Die Funktion prüft den HTTP-Status-Code, bevor sie
-        versucht die Antwort als JSON zu parsen.
-
-        Args:
-            bbox (tuple): Bounding Box als 4-Tuple in Dezimalgrad:
-                          (south, west, north, east)
-                          Beispiel Davos:   (46.72, 9.70, 46.92, 10.00)
-                          Beispiel Schweiz: (45.8,  5.9,  47.8,  10.5)
-
-        Returns:
-            dict: Geparste JSON-Antwort der Overpass API. Die Antwort enthält
-                  unter dem Schlüssel "elements" eine Liste von OSM-Objekten
-                  (nodes und ways) mit ihren Tags und Koordinaten.
-                  Beispiel:
-                  {
-                    "elements": [
-                      {
-                        "type": "node",
-                        "id": 123456,
-                        "lat": 46.8, "lon": 9.8,
-                        "tags": {"aerialway": "station", "name": "Jakobshorn"}
-                      },
-                      ...
-                    ]
-                  }
-
-        Raises:
-            RuntimeError: Wenn die API einen HTTP-Fehlercode zurückgibt
-                          (z.B. 429 Too Many Requests, 504 Gateway Timeout).
-            RuntimeError: Wenn der Response-Body kein gültiges JSON enthält
-                          (z.B. bei leerem Body nach einem Server-Timeout).
-            requests.Timeout: Wenn die API nicht innerhalb einer bestimmten Zeit
-                              (timeout) antwortet.
-        """
-    bbox_str = ",".join(map(str, bbox))
-    query = BERGBAHN_QUERY.format(bbox=bbox_str)
-
-    resp = requests.post(
-        OVERPASS_URL,
-        data={"data": query},
-        timeout=10,  # clientseitiges timeout ist nicht serverseitiges timeout (das ist im query selbst auf z.B. 3 Sekunden gestellt)
-        headers={"User-Agent": "GeoService/1.0 (poi-generator)"},
-    )
-
-    if resp.status_code != 200:
-        raise RuntimeError(
-            f"Overpass API Fehler: {resp.status_code}\n{resp.text}"
-        )
         try:
-        data = resp.json()
+            result = fetch_overpass(overpass_query=QUERY, bbox=bbox)
-    except requests.exceptions.JSONDecodeError:
+        except RuntimeError as e:
-        raise RuntimeError(
+            print(f"API-Fehler bei '{name}': {e}")
-            f"Antwort ist kein gültiges JSON:\n{resp.text[:200]}"
+            continue
-        )
+        except requests.Timeout:
-
+            print(f"Timeout bei '{name}' — bbox zu gross oder Server überlastet")
-    # HTTP 200 bedeutet nicht immer Erfolg — Overpass meldet Fehler im Body unter 'remark'!
+            continue
-    if "remark" in data:
-        raise RuntimeError(
-            f"Overpass Query-Fehler: {data['remark']}"
-        )
-
-    return data
 
+        elements = result.get("elements", [])
+        print(elements)
 
 
 if __name__ == "__main__":
+    main()
 
-    bbox = (46.72, 9.70, 46.92, 10.00)
-    # bbox = (45.8, 5.9, 47.8, 10.5)
-    result = fetch_bergbahnen(bbox)
-    pprint(result)
 
     # Was ist passiert?
-    # Wir haben verschiedene Fehler (verschiedene Ebenen) abgefangen:
+    # * Wir haben die Logik in ein eigenes Modul 'overpass' verfrachtet
-    # Ebene 1 — Netzwerk:     requests.Timeout         → Client wartet vergebens
+    # * Wir haben die Funktion von einer reinen Bergbahn-Logik befreit und für alle möglichen Overpass-Queries bereit
-    # Ebene 2 — HTTP:         status_code != 200       → Server meldet Fehler
+    #   gemacht (generalisiert)
-    # Ebene 3 — Fachlich:     "remark" im JSON-Body    → Query lief, aber mit Fehler
 
     # TASK:
-    # * verlagert als nächstes die Logik von 'fetch_bergbahnen' in ein eigenes Modul 'overpass.py' aus.
+
-    # * nennt die Funktion allgemeiner 'fetch_overpass' (anstelle fetch_bergbahnen) -> somit würde es Sinn
+    # * Jetzt wäre doch ein guter Zeitpunkt um anstelle der print-Statements das Logging einzubauen -> verwendet das
-    #   machen, wenn wir den Query der Funktion als Argument mitgeben könnten (ist genereller).
+    #   Logging-Modul in Python und ersetzt die print-statements!
-    # * Erstellt in diesem main.py eine eigene 'main-Funktion', welche nur die Hauptlogik beinhalten und somit 'fetch_overpass'
+    # * Hier haben wir einen weiteren Query für restaurants -> bildet ein neues Modul 'queries' und baut dort sowohl den
-    #   importiert und aufruft.
+    #   Bergbahn- als auch den Restaurant-Query ein:
+    #
+    #   RESTAURANT_QUERY = """
+    # [out:json][timeout:15][maxsize:500000];
+    # (
+    #   node["amenity"="restaurant"]({bbox});
+    #   way["amenity"="restaurant"]({bbox});
+    #   node["amenity"="cafe"]({bbox});
+    #   way["amenity"="cafe"]({bbox});
+    # );
+    # out center body;
+    # """

overpass.py

@@ -0,0 +1,97 @@
+import requests
+from pprint import pprint
+
+OVERPASS_URL = "https://overpass-api.de/api/interpreter"
+
+def fetch_overpass(overpass_query: str, bbox: tuple) -> dict:
+    """ Fragt die Overpass API mit einem beliebigen Query nach POIs in der angegebenen Bounding Box ab.
+
+    Sendet einen HTTP-POST-Request an die Overpass API und gibt die geparste
+    JSON-Antwort zurück. Die Funktion prüft den HTTP-Status-Code, einen
+    allfälligen Fehler im Response-Body sowie die JSON-Struktur der Antwort.
+
+    Args:
+        overpass_query (str): Overpass-QL-Query mit dem Platzhalter {bbox}.
+                              Beispiel:
+                              '[out:json][timeout:5];
+                               (node["aerialway"="station"]({bbox}););
+                               out center body;'
+        bbox (tuple): Bounding Box als 4-Tuple in Dezimalgrad:
+                      (south, west, north, east)
+                      Beispiel Davos:   (46.72, 9.70, 46.92, 10.00)
+                      Beispiel Schweiz: (45.8,  5.9,  47.8,  10.5)
+
+    Returns:
+        dict: Geparste JSON-Antwort der Overpass API. Die Antwort enthält
+              unter dem Schlüssel "elements" eine Liste von OSM-Objekten
+              (nodes und ways) mit ihren Tags und Koordinaten.
+              Beispiel:
+              {
+                "elements": [
+                  {
+                    "type": "node",
+                    "id": 123456,
+                    "lat": 46.8, "lon": 9.8,
+                    "tags": {"aerialway": "station", "name": "Jakobshorn"}
+                  },
+                  ...
+                ]
+              }
+
+    Raises:
+        RuntimeError: Wenn die API einen HTTP-Fehlercode zurückgibt
+                      (z.B. 429 Too Many Requests, 504 Gateway Timeout).
+        RuntimeError: Wenn der Response-Body kein gültiges JSON enthält
+                      (z.B. bei leerem Body nach einem Server-Timeout).
+        RuntimeError: Wenn Overpass einen fachlichen Fehler meldet
+                      (HTTP 200, aber "remark" im Body, z.B. bei
+                      Speicher- oder Timeout-Überschreitung).
+        requests.Timeout: Wenn die API nicht innerhalb des Client-Timeouts
+                          antwortet.
+    """
+    bbox_str = ",".join(map(str, bbox))
+    query = overpass_query.format(bbox=bbox_str)
+    resp = requests.post(
+        OVERPASS_URL,
+        data={"data": query},
+        timeout=40,  # clientseitiges timeout ist nicht serverseitiges timeout (das ist im query selbst auf z.B. 3 Sekunden gestellt)
+        headers={"User-Agent": "GeoService/1.0 (poi-generator)"},
+    )
+    if resp.status_code != 200:
+        raise RuntimeError(
+            f"Overpass API Fehler: {resp.status_code}\n{resp.text}"
+        )
+    try:
+        data = resp.json()
+    except requests.exceptions.JSONDecodeError:
+        raise RuntimeError(
+            f"Antwort ist kein gültiges JSON:\n{resp.text[:200]}"
+        )
+
+    # HTTP 200 bedeutet nicht immer Erfolg — Overpass meldet Fehler im Body!
+    if "remark" in data:
+        raise RuntimeError(
+            f"Overpass Query-Fehler: {data['remark']}"
+        )
+
+    return data
+
+
+if __name__ == "__main__":
+
+    BERGBAHN_QUERY = """
+    [out:json][timeout:2][maxsize:500000];
+    (
+      node["aerialway"="station"]({bbox});
+      way["aerialway"="station"]({bbox});
+      node["railway"="funicular"]({bbox});
+      way["railway"="funicular"]({bbox});
+      node["railway"="station"]["funicular"="yes"]({bbox});
+    );
+    out center body;
+    """
+
+    bbox = (46.72, 9.70, 46.92, 10.00)
+    # bbox = (45.8, 5.9, 47.8, 10.5)
+    result = fetch_overpass(overpass_query=BERGBAHN_QUERY, bbox=bbox)
+    pprint(result)