Update app.py

app.py

@@ -1,13 +1,17 @@
+import gradio as gr
 import requests
-import xml.etree.ElementTree as ET
 from datetime import datetime, timedelta
+import xml.etree.ElementTree as ET
 import json
 
 def get_station_info(pattern, client_id, api_key):
-    """Ermittelt EVA-Nummer und Namen für einen Suchbegriff."""
+    """Ermittelt EVA-Nummer und offiziellen Namen."""
     url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/station/{pattern}"
-    headers = {'DB-Client-Id': client_id, 'DB-Api-Key': api_key, 'accept': 'application/xml'}
-    
+    headers = {
+        'DB-Client-Id': client_id,
+        'DB-Api-Key': api_key,
+        'accept': 'application/xml'
+    }
     try:
         response = requests.get(url, headers=headers, timeout=10)
         response.raise_for_status()
@@ -20,10 +24,13 @@ def get_station_info(pattern, client_id, api_key):
     return None
 
 def fetch_timetable_hour(eva, date_str, hour_str, client_id, api_key):
-    """Hilt den Fahrplan für eine spezifische Stunde."""
+    """Ruft den Fahrplan für eine bestimmte Stunde ab."""
     url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{eva}/{date_str}/{hour_str}"
-    headers = {'DB-Client-Id': client_id, 'DB-Api-Key': api_key, 'accept': 'application/xml'}
-    
+    headers = {
+        'DB-Client-Id': client_id,
+        'DB-Api-Key': api_key,
+        'accept': 'application/xml'
+    }
     try:
         response = requests.get(url, headers=headers, timeout=10)
         if response.status_code == 200:
@@ -32,72 +39,93 @@ def fetch_timetable_hour(eva, date_str, hour_str, client_id, api_key):
         pass
     return None
 
-def get_next_connections_json(departure_name, destination_name, client_id, api_key):
-    """Sucht die nächsten 3 Verbindungen und gibt sie als JSON zurück."""
+def search_next_3_connections(departure, destination, client_id, api_key):
+    """Hauptfunktion: Findet die nächsten 3 Verbindungen ab 'jetzt'."""
     
-    # 1. Stationen auflösen
-    dep_info = get_station_info(departure_name, client_id, api_key)
-    dest_info = get_station_info(destination_name, client_id, api_key)
+    if not all([departure, destination, client_id, api_key]):
+        return {"error": "Bitte alle Felder ausfüllen."}
+
+    # 1. IBNRs ermitteln
+    dep_info = get_station_info(departure, client_id, api_key)
+    dest_info = get_station_info(destination, client_id, api_key)
     
-    if not dep_info or not dest_info:
-        return json.dumps({"error": "Station nicht gefunden"}, indent=4)
+    if not dep_info: return {"error": f"Startort '{departure}' nicht gefunden."}
+    if not dest_info: return {"error": f"Zielort '{destination}' nicht gefunden."}
 
-    # 2. Zeitstempel vorbereiten
     now = datetime.now()
-    all_found_connections = []
+    found_connections = []
     
-    # Wir prüfen die aktuelle und die nächste Stunde, um sicherzugehen, dass wir 3 finden
-    for hour_offset in range(2):
+    # 2. Suche in der aktuellen und der nächsten Stunde (um 3 Verbindungen zu garantieren)
+    for hour_offset in range(3): # Wir schauen bis zu 2 Stunden voraus
         search_time = now + timedelta(hours=hour_offset)
         datum = search_time.strftime("%y%m%d")
         stunde = search_time.strftime("%H")
         
         root = fetch_timetable_hour(dep_info['eva'], datum, stunde, client_id, api_key)
-        if root is None:
-            continue
+        if root is None: continue
             
         for train in root.findall('.//s'):
             dp = train.find('dp')
             if dp is None: continue
             
-            # Prüfen ob Ziel im Pfad
+            # Prüfen ob Ziel im geplanten Pfad (ppth)
             path = dp.get('ppth', '')
-            if dest_info['name'].lower() in path.lower() or destination_name.lower() in path.lower():
+            if dest_info['name'].lower() in path.lower() or destination.lower() in path.lower():
                 
-                # Zeit-Parsing (Format: YYMMDDHHMM)
-                pt = dp.get('pt', '')
+                pt = dp.get('pt', '') # Geplante Zeit: YYMMDDHHMM
                 if not pt: continue
                 
-                # In datetime Objekt umwandeln für Vergleich und Sortierung
                 dep_dt = datetime.strptime(pt, "%y%m%d%H%M")
                 
-                # Nur Züge in der Zukunft berücksichtigen
+                # Nur Verbindungen in der Zukunft (ab Zeitstempel jetzt)
                 if dep_dt >= now:
-                    all_found_connections.append({
+                    tl = train.find('tl')
+                    found_connections.append({
                         "startort": dep_info['name'],
                         "zielort": dest_info['name'],
                         "abfahrtszeit": dep_dt.strftime("%d.%m.%Y %H:%M"),
                         "gleis": dp.get('pp', 'n/a'),
-                        "zug": f"{train.find('tl').get('c')} {train.find('tl').get('n')}",
-                        "_dt": dep_dt # Intern für Sortierung
+                        "zug": f"{tl.get('c', '')} {tl.get('n', '')}",
+                        "_dt": dep_dt # Hilfsfeld zum Sortieren
                     })
 
-    # 3. Sortieren nach Zeit und Top 3 extrahieren
-    all_found_connections.sort(key=lambda x: x['_dt'])
+    # 3. Sortieren und Top 3 auswählen
+    found_connections.sort(key=lambda x: x['_dt'])
     
-    # Entferne internes Hilfsfeld _dt und limitiere auf 3
-    final_list = []
-    for c in all_found_connections[:3]:
-        del c['_dt']
-        final_list.append(c)
+    # Bereinigen der Ergebnisse für die JSON-Ausgabe
+    final_results = []
+    for c in found_connections[:3]:
+        # Entferne das interne Datetime-Objekt vor der JSON-Konvertierung
+        res = {k: v for k, v in c.items() if k != "_dt"}
+        final_results.append(res)
+
+    return final_results
+
+# --- Gradio UI ---
 
-    return json.dumps(final_list, indent=4, ensure_ascii=False)
+def ui_wrapper(dep, dest, cid, akey):
+    results = search_next_3_connections(dep, dest, cid, akey)
+    return json.dumps(results, indent=4, ensure_ascii=False)
 
-# --- Beispielaufruf ---
-# client_id = "DEINE_ID"
-# api_key = "DEIN_KEY"
-# print(get_next_connections_json("Frankfurt Hbf", "Berlin", client_id, api_key))
+with gr.Blocks(title="DB JSON Fahrplan", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🚆 DB Verbindungs-Suche (JSON)")
+    gr.Markdown("Ermittelt die nächsten 3 Verbindungen ab dem aktuellen Zeitstempel.")
+    
+    with gr.Row():
+        cid_input = gr.Textbox(label="DB Client ID", type="password")
+        akey_input = gr.Textbox(label="DB API Key", type="password")
+        
+    with gr.Row():
+        dep_input = gr.Textbox(label="Abfahrtsort", placeholder="z.B. Berlin")
+        dest_input = gr.Textbox(label="Zielort", placeholder="z.B. Hamburg")
+        
+    btn = gr.Button("Suchen", variant="primary")
+    output = gr.JSON(label="JSON Ergebnis") # Nutzt Gradio JSON Komponente für schöneres Format
+    
+    btn.click(fn=ui_wrapper, inputs=[dep_input, dest_input, cid_input, akey_input], outputs=output)
 
+if __name__ == "__main__":
+    demo.launch()
 
 """
 import gradio as gr