Update app.py

app.py

@@ -1,164 +1,187 @@
 import gradio as gr
 import requests
-from datetime import datetime, timedelta
+from datetime import datetime
 import xml.etree.ElementTree as ET
-import json
 
 def get_station_info(pattern, client_id, api_key):
-    """Sucht Bahnhof und gibt Name sowie EVA-Nummer zurück."""
+    """
+    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'}
-    try:
-        response = requests.get(url, headers=headers, timeout=10)
-        root = ET.fromstring(response.content)
-        station = root.find('station')
-        if station is not None:
-            return {'name': station.get('name'), 'eva': station.get('eva')}
-    except:
-        return None
-    return None
+    
+    headers = {
+        'DB-Client-Id': client_id,
+        'DB-Api-Key': api_key,
+        'accept': 'application/xml'
+    }
 
-def get_arrival_info(trip_id, dest_eva, client_id, api_key):
-    """Ruft die Ankunftszeit für eine spezifische trip_id am Ziel-Bahnhof ab."""
-    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
+        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
 
-def calculate_duration(dep_raw, arr_raw):
-    """Berechnet die Reisedauer aus zwei Zeitstempeln (YYMMDDHHMM)."""
-    try:
-        fmt = "%y%m%d%H%M"
-        dep_dt = datetime.strptime(dep_raw, fmt)
-        arr_dt = datetime.strptime(arr_raw, fmt)
-        diff = arr_dt - dep_dt
-        hours, remainder = divmod(int(diff.total_seconds()), 3600)
-        minutes = remainder // 60
-        return f"{hours}h {minutes}min"
-    except:
-        return "n/a"
+    except Exception as e:
+        print(f"Fehler bei Stationssuche: {e}")
+        return None
 
 def search_connections(departure, destination, client_id, api_key):
-    if not all([departure, destination, client_id, api_key]):
-        return "❌ Bitte alle Felder ausfüllen.", []
-
+    """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."
 
-    if not dep_info or not dest_info:
-        return "❌ Bahnhof nicht gefunden. Bitte Schreibweise prüfen.", []
-
+    departure_eva = dep_info['eva']
+    departure_name = dep_info['name']
+    destination_name = dest_info['name']
+    
+    # Aktuelles Datum und Stunde
     now = datetime.now()
-    found_conns = []
-
-    # Suche über die nächsten 12 Stunden hinweg
-    for hour_offset in range(12):
-        if len(found_conns) >= 3:
-            break
+    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"
+    }
+    
+    try:
+        response = requests.get(url, headers=headers, timeout=10)
         
-        search_time = now + timedelta(hours=hour_offset)
-        datum = search_time.strftime("%y%m%d")
-        stunde = search_time.strftime("%H")
+        if response.status_code != 200:
+            return f"❌ API Fehler beim Abrufen des Fahrplans: {response.status_code}"
         
-        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'}
+        root = ET.fromstring(response.content)
+        connections = []
         
-        try:
-            response = requests.get(url, headers=headers, timeout=10)
-            if response.status_code != 200:
+        for train in root.findall('.//s'):
+            dp = train.find('dp')
+            if dp is None:
                 continue
             
-            root = ET.fromstring(response.content)
-            for s in root.findall('.//s'):
-                dp = s.find('dp')
-                if dp is None:
-                    continue
+            # Route des Zugs (ppth = planned path)
+            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}"
                 
-                path = dp.get('ppth', '')
-                # Prüfen ob Ziel im Fahrtverlauf
-                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 - timedelta(minutes=2)):
-                        trip_id = s.get('id')
-                        arr_raw = get_arrival_info(trip_id, dest_info['eva'], client_id, api_key)
-                        
-                        if arr_raw:
-                            tl = s.find('tl')
-                            arr_dt = datetime.strptime(arr_raw, "%y%m%d%H%M")
-                            
-                            found_conns.append({
-                                "zug": f"{tl.get('c','')}{tl.get('n','')}",
-                                "abfahrt": dep_dt.strftime("%H:%M"),
-                                "ankunft": arr_dt.strftime("%H:%M"),
-                                "dauer": calculate_duration(dep_raw, arr_raw),
-                                "gleis": dp.get('pp', '-'),
-                                "start": dep_info['name'],
-                                "ziel": dest_info['name'],
-                                "_dt": dep_dt
-                            })
-                            if len(found_conns) >= 3:
-                                break
-        except:
-            continue
-
-    found_conns.sort(key=lambda x: x['_dt'])
-    return None, found_conns[:3]
+                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)}"
 
-def main(departure, destination, client_id, api_key):
-    err, conns = search_connections(departure, destination, client_id, api_key)
+# 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.
+        """
+    )
     
-    if err:
-        return err, json.dumps({"error": err})
-    if not conns:
-        return "Keine Direktverbindungen gefunden.", "[]"
-    
-    # JSON Output (ohne internes Sortierfeld)
-    clean_json = [{k: v for k, v in c.items() if k != "_dt"} for c in conns]
+    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")
     
-    # Markdown Tabelle (Flat & Professional)
-    md = f"### 🚆 {conns[0]['start']} → {conns[0]['ziel']}\n\n"
-    md += "| Zug | Abfahrt | Ankunft | Dauer | Gleis |\n"
-    md += "|:---|:---|:---|:---|:---|\n"
-    for c in clean_json:
-        md += f"| **{c['zug']}** | {c['abfahrt']} | {c['ankunft']} | {c['dauer']} | {c['gleis']} |\n"
+    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"
+            )
     
-    md += f"\n\n*Abfragezeitpunkt: {datetime.now().strftime('%H:%M')}*"
+    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary")
     
-    return md, clean_json
-
-# --- Gradio UI ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚄 DB Timetable Service")
-    with gr.Row():
-        cid = gr.Textbox(label="Client ID", type="password")
-        akey = gr.Textbox(label="API Key", type="password")
-    with gr.Row():
-        start = gr.Textbox(label="Start", placeholder="z.B. Berlin Hbf")
-        ziel = gr.Textbox(label="Ziel", placeholder="z.B. Hamburg Hbf")
+    output = gr.Textbox(label="Ergebnisse", lines=20)
     
-    btn = gr.Button("Nächste 3 Verbindungen 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.
+        """
+    )
     
-    output_md = gr.Markdown()
-    output_json = gr.JSON(label="JSON Result")
-
-    btn.click(main, [start, ziel, cid, akey], [output_md, output_json])
+    search_button.click(
+        fn=search_connections,
+        inputs=[departure_input, destination_input, client_id_input, api_key_input],
+        outputs=output
+    )
 
 if __name__ == "__main__":
     demo.launch()
-
-
 """
 import gradio as gr
 import requests