Update app.py

app.py

@@ -1,187 +1,104 @@
-import gradio as gr
 import requests
-from datetime import datetime
 import xml.etree.ElementTree as ET
+from datetime import datetime, timedelta
+import json
 
 def get_station_info(pattern, client_id, api_key):
-    """
-    Sucht über die Timetables API nach einem Bahnhof und gibt EVA-Nummer 
-    und den korrekten Namen zurück.
-    """
+    """Ermittelt EVA-Nummer und Namen für einen Suchbegriff."""
     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()
-        
         root = ET.fromstring(response.content)
-        stations = []
-        for station in root.findall('station'):
-            stations.append({
-                'name': station.get('name'),
-                'eva': station.get('eva')
-            })
-        
-        # Falls Stationen gefunden wurden, nehmen wir die erste (beste Übereinstimmung)
-        return stations[0] if stations else None
-
-    except Exception as e:
-        print(f"Fehler bei Stationssuche: {e}")
+        station = root.find('station')
+        if station is not None:
+            return {'name': station.get('name'), 'eva': station.get('eva')}
+    except Exception:
         return None
+    return None
 
-def search_connections(departure, destination, client_id, api_key):
-    """Sucht Verbindungen zwischen zwei Bahnhöfen"""
-    
-    if not departure or not destination:
-        return "❌ Bitte Abfahrts- und Zielort eingeben"
+def fetch_timetable_hour(eva, date_str, hour_str, client_id, api_key):
+    """Hilt den Fahrplan für eine spezifische Stunde."""
+    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'}
     
-    if not client_id or not api_key:
-        return "❌ Bitte Client ID und API Key eingeben"
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
+        if response.status_code == 200:
+            return ET.fromstring(response.content)
+    except Exception:
+        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."""
     
-    # 1. IBNR (EVA) für Abfahrtsort ermitteln
-    dep_info = get_station_info(departure, client_id, api_key)
-    if not dep_info:
-        return f"❌ Abfahrtsort '{departure}' wurde nicht gefunden."
+    # 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)
     
-    # 2. IBNR (EVA) für Zielort ermitteln (für genaueres Matching im Pfad)
-    dest_info = get_station_info(destination, client_id, api_key)
-    if not dest_info:
-        return f"❌ Zielort '{destination}' wurde nicht gefunden."
+    if not dep_info or not dest_info:
+        return json.dumps({"error": "Station nicht gefunden"}, indent=4)
 
-    departure_eva = dep_info['eva']
-    departure_name = dep_info['name']
-    destination_name = dest_info['name']
-    
-    # Aktuelles Datum und Stunde
+    # 2. Zeitstempel vorbereiten
     now = datetime.now()
-    datum = now.strftime("%y%m%d")  # YYMMDD
-    stunde = now.strftime("%H")      # HH
-    
-    # API-Aufruf für den Fahrplan
-    url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{departure_eva}/{datum}/{stunde}"
+    all_found_connections = []
     
-    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:
-            return f"❌ API Fehler beim Abrufen des Fahrplans: {response.status_code}"
-        
-        root = ET.fromstring(response.content)
-        connections = []
+    # Wir prüfen die aktuelle und die nächste Stunde, um sicherzugehen, dass wir 3 finden
+    for hour_offset in range(2):
+        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
+            
         for train in root.findall('.//s'):
             dp = train.find('dp')
-            if dp is None:
-                continue
+            if dp is None: continue
             
-            # Route des Zugs (ppth = planned path)
+            # Prüfen ob Ziel im Pfad
             path = dp.get('ppth', '')
-            
-            # Prüfen ob Zielort im Pfad enthalten ist
-            # Wir prüfen sowohl den eingegebenen Namen als auch den gefundenen offiziellen Namen
-            if destination_name.lower() in path.lower() or destination.lower() in path.lower():
-                # Zugdetails extrahieren
-                tl = train.find('tl') # Train Label
-                train_class = tl.get('c', '') # z.B. ICE
-                train_number = tl.get('n', '') # z.B. 123
-                full_train_name = f"{train_class} {train_number}"
-                
-                planned_time = dp.get('pt', '')
-                platform = dp.get('pp', 'n/a')
+            if dest_info['name'].lower() in path.lower() or destination_name.lower() in path.lower():
                 
-                if len(planned_time) == 10: # Format YYMMDDHHMM
-                    planned_time = f"{planned_time[8:10]}:{planned_time[10:12]}"
-                elif len(planned_time) == 4:
-                    planned_time = f"{planned_time[:2]}:{planned_time[2:]}"
+                # Zeit-Parsing (Format: YYMMDDHHMM)
+                pt = dp.get('pt', '')
+                if not pt: continue
                 
-                route = ' → '.join(path.split('|'))
+                # In datetime Objekt umwandeln für Vergleich und Sortierung
+                dep_dt = datetime.strptime(pt, "%y%m%d%H%M")
                 
-                connections.append({
-                    'train': full_train_name,
-                    'time': planned_time,
-                    'platform': platform,
-                    'route': route
-                })
-        
-        if not connections:
-            return f"ℹ️ Keine direkten Verbindungen von {departure_name} nach {destination_name} gefunden.\n(Suche im Zeitraum {now.strftime('%H:00')} - {int(now.strftime('%H'))+1}:00 Uhr)"
-        
-        result = f"🚆 Verbindungen von: {departure_name}\n"
-        result += f"🏁 Ziel: {destination_name}\n"
-        result += f"📅 Datum: {now.strftime('%d.%m.%Y')}\n\n"
-        
-        for i, conn in enumerate(connections[:15], 1):
-            result += f"─────────────────────────────────\n"
-            result += f"{i}. {conn['train']}\n"
-            result += f"   ⏰ Abfahrt: {conn['time']} Uhr\n"
-            result += f"   🚉 Gleis: {conn['platform']}\n"
-            result += f"   🗺️  Route: {conn['route'][:100]}...\n\n"
-        
-        return result
-        
-    except Exception as e:
-        return f"❌ Fehler: {str(e)}"
+                # Nur Züge in der Zukunft berücksichtigen
+                if dep_dt >= now:
+                    all_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
+                    })
 
-# Gradio Interface
-with gr.Blocks(title="DB Timetable API - Live Suche", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-        # 🚆 DB Live-Fahrplanauskunft
-        Ermittelt automatisch die IBNR (EVA-Nummer) und sucht nach Verbindungen.
-        """
-    )
-    
-    with gr.Row():
-        with gr.Column():
-            client_id_input = gr.Textbox(label="DB Client ID", type="password")
-            api_key_input = gr.Textbox(label="DB API Key", type="password")
+    # 3. Sortieren nach Zeit und Top 3 extrahieren
+    all_found_connections.sort(key=lambda x: x['_dt'])
     
-    with gr.Row():
-        with gr.Column():
-            departure_input = gr.Textbox(
-                label="Abfahrtsort", 
-                placeholder="z.B. Berlin Hbf oder Frankfurt"
-            )
-        with gr.Column():
-            destination_input = gr.Textbox(
-                label="Zielort", 
-                placeholder="z.B. München Hbf"
-            )
-    
-    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary")
-    
-    output = gr.Textbox(label="Ergebnisse", lines=20)
-    
-    gr.Markdown(
-        """
-        ### ℹ️ Funktionsweise
-        1. Die App sendet Ihren Suchbegriff an den `/station` Endpoint.
-        2. Die erste gefundene **EVA-Nummer (IBNR)** wird für die Abfrage genutzt.
-        3. Der Fahrplan für die aktuelle Stunde wird abgerufen.
-        4. Es wird gefiltert, ob der Zielbahnhof im geplanten Fahrtverlauf vorkommt.
-        """
-    )
-    
-    search_button.click(
-        fn=search_connections,
-        inputs=[departure_input, destination_input, client_id_input, api_key_input],
-        outputs=output
-    )
+    # Entferne internes Hilfsfeld _dt und limitiere auf 3
+    final_list = []
+    for c in all_found_connections[:3]:
+        del c['_dt']
+        final_list.append(c)
+
+    return json.dumps(final_list, 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))
+
 
-if __name__ == "__main__":
-    demo.launch()
 """
 import gradio as gr
 import requests