Update app.py

app.py

@@ -3,29 +3,37 @@ import requests
 from datetime import datetime
 import xml.etree.ElementTree as ET
 
-# EVA-Nummern für Hauptbahnhöfe
-STATION_EVA = {
-    'frankfurt': '8000105',
-    'berlin': '8011160',
-    'münchen': '8000261',
-    'hamburg': '8002549',
-    'köln': '8000207',
-    'stuttgart': '8000096',
-    'düsseldorf': '8000085',
-    'dortmund': '8000080',
-    'essen': '8000098',
-    'leipzig': '8010205',
-    'bremen': '8000050',
-    'dresden': '8010085',
-    'hannover': '8000152',
-    'nürnberg': '8000284',
-    'duisburg': '8000086',
-}
+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'
+    }
+
+    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
 
-def get_eva_number(station_name):
-    """Wandelt Stationsnamen in EVA-Nummer um"""
-    normalized = station_name.lower().strip()
-    return STATION_EVA.get(normalized)
+    except Exception as e:
+        print(f"Fehler bei Stationssuche: {e}")
+        return None
 
 def search_connections(departure, destination, client_id, api_key):
     """Sucht Verbindungen zwischen zwei Bahnhöfen"""
@@ -36,18 +44,26 @@ def search_connections(departure, destination, client_id, api_key):
     if not client_id or not api_key:
         return "❌ Bitte Client ID und API Key eingeben"
     
-    # EVA-Nummer für Abfahrtsort ermitteln
-    departure_eva = get_eva_number(departure)
-    if not departure_eva:
-        available = ', '.join(STATION_EVA.keys())
-        return f"❌ Station '{departure}' nicht gefunden.\n\nVerfügbare Stationen: {available}"
+    # 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
     now = datetime.now()
     datum = now.strftime("%y%m%d")  # YYMMDD
     stunde = now.strftime("%H")      # HH
     
-    # API-Aufruf
+    # API-Aufruf für den Fahrplan
     url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{departure_eva}/{datum}/{stunde}"
     
     headers = {
@@ -60,122 +76,101 @@ def search_connections(departure, destination, client_id, api_key):
         response = requests.get(url, headers=headers, timeout=10)
         
         if response.status_code != 200:
-            return f"❌ API Fehler: {response.status_code} - {response.text[:200]}"
+            return f"❌ API Fehler beim Abrufen des Fahrplans: {response.status_code}"
         
-        # XML parsen
         root = ET.fromstring(response.content)
         connections = []
         
-        # Alle Züge durchgehen
         for train in root.findall('.//s'):
-            # Abfahrtsinformationen
             dp = train.find('dp')
             if dp is None:
                 continue
             
-            # Route des Zugs
+            # Route des Zugs (ppth = planned path)
             path = dp.get('ppth', '')
             
-            # Prüfen ob Zielort in Route enthalten ist
-            if destination.lower() in path.lower():
-                train_id = train.get('id', 'Unbekannt')
+            # 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')
                 
-                # Zeit formatieren (von HHMM zu HH:MM)
-                if len(planned_time) == 4:
+                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 formatieren
                 route = ' → '.join(path.split('|'))
                 
                 connections.append({
-                    'train': train_id,
+                    'train': full_train_name,
                     'time': planned_time,
                     'platform': platform,
                     'route': route
                 })
         
-        # Ergebnisse formatieren
         if not connections:
-            return f"ℹ️ Keine direkten Verbindungen von {departure.title()} nach {destination.title()} gefunden.\n\nHinweis: Die App sucht nur nach direkten Verbindungen in der nächsten Stunde."
+            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.title()} nach {destination.title()}\n"
-        result += f"📅 {now.strftime('%d.%m.%Y')} ab {now.strftime('%H:00')} Uhr\n\n"
+        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[:10], 1):
+        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']}\n\n"
+            result += f"   🗺️  Route: {conn['route'][:100]}...\n\n"
         
         return result
         
-    except requests.exceptions.Timeout:
-        return "❌ Zeitüberschreitung bei der API-Anfrage"
-    except requests.exceptions.RequestException as e:
-        return f"❌ Netzwerkfehler: {str(e)}"
-    except ET.ParseError as e:
-        return f"❌ Fehler beim Parsen der XML-Antwort: {str(e)}"
     except Exception as e:
-        return f"❌ Unerwarteter Fehler: {str(e)}"
+        return f"❌ Fehler: {str(e)}"
 
-# Gradio Interface erstellen
-with gr.Blocks(title="Deutsche Bahn Fahrplanauskunft", theme=gr.themes.Soft()) as demo:
+# Gradio Interface
+with gr.Blocks(title="DB Timetable API - Live Suche", theme=gr.themes.Soft()) as demo:
     gr.Markdown(
         """
-        # 🚆 Deutsche Bahn Fahrplanauskunft
-        Finden Sie Zugverbindungen mit der DB Timetable API
+        # 🚆 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",
-                placeholder="Ihre Client ID von developers.deutschebahn.com",
-                type="password"
-            )
-            api_key_input = gr.Textbox(
-                label="DB API Key",
-                placeholder="Ihr API Key",
-                type="password"
-            )
+            client_id_input = gr.Textbox(label="DB Client ID", type="password")
+            api_key_input = gr.Textbox(label="DB API Key", type="password")
     
     with gr.Row():
         with gr.Column():
             departure_input = gr.Textbox(
-                label="Abfahrtsort",
-                placeholder="z.B. Frankfurt",
-                value=""
+                label="Abfahrtsort", 
+                placeholder="z.B. Berlin Hbf oder Frankfurt"
             )
         with gr.Column():
             destination_input = gr.Textbox(
-                label="Zielort",
-                placeholder="z.B. Berlin",
-                value=""
+                label="Zielort", 
+                placeholder="z.B. München Hbf"
             )
     
-    gr.Markdown("⏰ **Abfahrtszeit:** Jetzt (automatisch)")
+    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary")
     
-    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary", size="lg")
-    
-    output = gr.Textbox(
-        label="Ergebnisse",
-        lines=20,
-        max_lines=30
-    )
+    output = gr.Textbox(label="Ergebnisse", lines=20)
     
     gr.Markdown(
-        f"""
-        ### 📍 Verfügbare Stationen
-        {', '.join(sorted(STATION_EVA.keys()))}
-        
-        ### ℹ️ Hinweise
-        - Sie benötigen einen kostenlosen API-Zugang von [DB API Marketplace](https://developers.deutschebahn.com)
-        - Die App sucht nach direkten Verbindungen in der aktuellen Stunde
-        - Geben Sie Städtenamen ohne "Hbf" ein (z.B. "Frankfurt" statt "Frankfurt Hbf")
+        """
+        ### ℹ️ 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.
         """
     )