Update app.py

app.py

@@ -1,191 +1,153 @@
 import gradio as gr
 import requests
-from datetime import datetime
+from datetime import datetime, timedelta
 import xml.etree.ElementTree as ET
+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.
-    """
     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
+        station = root.find('station')
+        if station is not None:
+            return {'name': station.get('name'), 'eva': station.get('eva')}
+    except: return None
+    return None
 
-    except Exception as e:
-        print(f"Fehler bei Stationssuche: {e}")
-        return None
+def get_arrival_info(trip_id, dest_eva, client_id, api_key):
+    """Holt die Ankunftszeit am Zielort für eine spezifische Fahrt."""
+    url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/journey/{trip_id}"
+    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:
+            root = ET.fromstring(response.content)
+            for stop in root.findall('.//s'):
+                if stop.get('eva') == dest_eva:
+                    ar = stop.find('ar')
+                    if ar is not None:
+                        return ar.get('pt') # Format: YYMMDDHHMM
+    except: pass
+    return None
+
+def calculate_duration(dep_raw, arr_raw):
+    """Berechnet die Reisedauer."""
+    try:
+        fmt = "%y%m%d%H%M"
+        diff = datetime.strptime(arr_raw, fmt) - datetime.strptime(dep_raw, fmt)
+        hours, remainder = divmod(diff.total_seconds(), 3600)
+        minutes = remainder // 60
+        return f"{int(hours)}h {int(minutes)}min"
+    except: return "n/a"
+
+def get_connections(departure, destination, client_id, api_key):
+    if not all([departure, destination, client_id, api_key]):
+        return None, "❌ Bitte alle Felder ausfüllen."
 
-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"
-    
-    if not client_id or not api_key:
-        return "❌ Bitte Client ID und API Key eingeben"
-    
-    # 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."
-    
-    # 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."
-
-    departure_eva = dep_info['eva']
-    departure_name = dep_info['name']
-    destination_name = dest_info['name']
     
-    # Aktuelles Datum und Stunde
+    if not dep_info or not dest_info:
+        return None, "❌ Bahnhof nicht gefunden."
+
     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}"
-    
-    headers = {
-        "DB-Client-Id": client_id,
-        "DB-Api-Key": api_key,
-        "accept": "application/xml"
-    }
+    found_connections = []
     
-    try:
-        response = requests.get(url, headers=headers, timeout=10)
+    # Suche über 12 Stunden hinweg, um sicher 3 Verbindungen zu finden
+    for hour_offset in range(12):
+        if len(found_connections) >= 3: break
         
-        if response.status_code != 200:
-            return f"❌ API Fehler beim Abrufen des Fahrplans: {response.status_code}"
+        search_time = now + timedelta(hours=hour_offset)
+        datum = search_time.strftime("%y%m%d")
+        stunde = search_time.strftime("%H")
         
-        root = ET.fromstring(response.content)
-        connections = []
+        url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{dep_info['eva']}/{datum}/{stunde}"
+        headers = {'DB-Client-Id': client_id, 'DB-Api-Key': api_key, 'accept': 'application/xml'}
         
-        for train in root.findall('.//s'):
-            dp = train.find('dp')
-            if dp is None:
-                continue
-            
-            # Route des Zugs (ppth = planned path)
-            path = dp.get('ppth', '')
+        try:
+            response = requests.get(url, headers=headers, timeout=10)
+            if response.status_code != 200: continue
+            root = ET.fromstring(response.content)
             
-            # 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}"
+            for train in root.findall('.//s'):
+                dp = train.find('dp')
+                if dp is None: continue
                 
-                planned_time = dp.get('pt', '')
-                platform = dp.get('pp', 'n/a')
-                
-                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:]}"
-                
-                route = ' → '.join(path.split('|'))
-                
-                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)}"
+                path = dp.get('ppth', '')
+                # Suche im Pfad nach dem Namen oder der EVA des Ziels
+                if dest_info['name'].lower() in path.lower() or destination.lower() in path.lower():
+                    dep_raw = dp.get('pt', '')
+                    dep_dt = datetime.strptime(dep_raw, "%y%m%d%H%M")
+                    
+                    if dep_dt >= now:
+                        # Journey Details für Ankunft und Dauer
+                        trip_id = train.get('id')
+                        arr_raw = get_arrival_info(trip_id, dest_info['eva'], client_id, api_key)
+                        
+                        arrival_time = datetime.strptime(arr_raw, "%y%m%d%H%M").strftime("%H:%M") if arr_raw else "n/a"
+                        duration = calculate_duration(dep_raw, arr_raw) if arr_raw else "n/a"
+                        
+                        tl = train.find('tl')
+                        found_connections.append({
+                            "zug": f"{tl.get('c', '')}{tl.get('n', '')}",
+                            "abfahrt": dep_dt.strftime("%H:%M"),
+                            "ankunft": arrival_time,
+                            "dauer": duration,
+                            "gleis": dp.get('pp', '-'),
+                            "start": dep_info['name'],
+                            "ziel": dest_info['name'],
+                            "_dt": dep_dt
+                        })
+                        if len(found_connections) >= 3: break
+        except: continue
 
-# 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.
-        """
-    )
+    found_connections.sort(key=lambda x: x['_dt'])
+    return found_connections[:3], None
+
+def main_interface(dep, dest, cid, akey):
+    conns, error = get_connections(dep, dest, cid, akey)
+    if error: return error, json.dumps({"error": error})
+    if not conns: return "Keine Verbindungen gefunden.", "[]"
     
-    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")
+    # JSON-Output (Clean)
+    json_output = [{k: v for k, v in c.items() if k != "_dt"} for c in conns]
+    
+    # Professional Markdown Table
+    md = f"### 🚆 {conns[0]['start']} → {conns[0]['ziel']}\n\n"
+    md += "| Zug | Abfahrt | Ankunft | Dauer | Gleis |\n"
+    md += "|:---|:---|:---|:---|:---|\n"
+    for c in json_output:
+        md += f"| **{c['zug']}** | {c['abfahrt']} | {c['ankunft']} | {c['dauer']} | {c['gleis']} |\n"
+    
+    md += f"\n\n*Abfrage: {datetime.now().strftime('%H:%M')}*"
+    
+    return md, json.dumps(json_output, indent=4, ensure_ascii=False)
+
+# --- Gradio UI ---
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🚄 DB Verbindungs-Check")
     
     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"
-            )
+        cid_input = gr.Textbox(label="Client ID", type="password")
+        akey_input = gr.Textbox(label="API Key", type="password")
     
-    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary")
+    with gr.Row():
+        dep_input = gr.Textbox(label="Start", placeholder="z.B. Berlin Hbf")
+        dest_input = gr.Textbox(label="Ziel", placeholder="z.B. Hamburg Hbf")
     
-    output = gr.Textbox(label="Ergebnisse", lines=20)
+    btn = gr.Button("Suchen", variant="primary")
     
-    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.
-        """
-    )
+    md_display = gr.Markdown()
+    json_display = gr.Code(label="JSON", language="json")
     
-    search_button.click(
-        fn=search_connections,
-        inputs=[departure_input, destination_input, client_id_input, api_key_input],
-        outputs=output
-    )
+    btn.click(main_interface, [dep_input, dest_input, cid_input, akey_input], [md_display, json_display])
 
 if __name__ == "__main__":
     demo.launch()
 
 
-
-
 """
 import gradio as gr
 import requests