Update app.py

app.py

@@ -3,7 +3,6 @@ import requests
 from datetime import datetime, timedelta
 import xml.etree.ElementTree as ET
 import json
-import os
 
 def get_station_info(pattern, client_id, api_key):
     """Ermittelt EVA-Nummer und offiziellen Namen."""
@@ -40,122 +39,90 @@ def fetch_timetable_hour(eva, date_str, hour_str, client_id, api_key):
         pass
     return None
 
-def fetch_journey_details(journey_id, client_id, api_key):
-    """Ruft die detaillierten Journey-Informationen ab."""
-    url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/journeyDetails/{journey_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:
-            return ET.fromstring(response.content)
-    except Exception:
-        pass
-    return None
-
-def search_next_3_connections(departure, destination):
+def search_next_3_connections(departure, destination, client_id, api_key):
     """Hauptfunktion: Findet die nächsten 3 Verbindungen ab 'jetzt'."""
-    client_id = os.getenv('client_id')
-    api_key = os.getenv('api_key')
+    
     if not all([departure, destination, client_id, api_key]):
-        return {"error": "Bitte alle Felder ausfüllen oder Umgebungsvariablen setzen."}
+        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:
-        return {"error": f"Startort '{departure}' nicht gefunden."}
-    if not dest_info:
-        return {"error": f"Zielort '{destination}' nicht gefunden."}
+    
+    if not dep_info: return {"error": f"Startort '{departure}' nicht gefunden."}
+    if not dest_info: return {"error": f"Zielort '{destination}' nicht gefunden."}
 
     now = datetime.now()
     found_connections = []
-
-    # 2. Suche in der aktuellen und den nächsten Stunden (um 3 Verbindungen zu garantieren)
-    for hour_offset in range(3):  # Wir schauen bis zu 2 Stunden voraus
+    
+    # 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
+            if dp is None: continue
+            
             # Prüfen ob Ziel im geplanten Pfad (ppth)
             path = dp.get('ppth', '')
-            if dest_info['name'].lower() not in path.lower() and destination.lower() not in path.lower():
-                continue
-            pt = dp.get('pt', '')  # Geplante Zeit: YYMMDDHHMM
-            if not pt:
-                continue
-            dep_dt = datetime.strptime(pt, "%y%m%d%H%M")
-            # Nur Verbindungen in der Zukunft (ab Zeitstempel jetzt)
-            if dep_dt < now:
-                continue
-            # Hole Journey Details
-            journey_id = train.get('id')
-            if not journey_id:
-                continue
-            details_root = fetch_journey_details(journey_id, client_id, api_key)
-            if details_root is None:
-                continue
-            # Finde den Stop am Ziel
-            arr_dt = None
-            for stop in details_root.findall('.//stop'):
-                if stop.get('eva') == dest_info['eva']:
-                    ar = stop.find('ar')
-                    if ar is not None:
-                        arr_pt = ar.get('pt', '')
-                        if arr_pt:
-                            arr_dt = datetime.strptime(arr_pt, "%y%m%d%H%M")
-                            break
-            if arr_dt is None:
-                continue  # Ziel nicht gefunden oder keine Ankunftszeit
-            # Berechne Duration
-            duration_delta = arr_dt - dep_dt
-            duration_minutes = int(duration_delta.total_seconds() / 60)
-            duration_str = f"{duration_minutes // 60:02d}:{duration_minutes % 60:02d}"
-            tl = train.find('tl')
-            found_connections.append({
-                "startort": dep_info['name'],
-                "zielort": dest_info['name'],
-                "abfahrtszeit": dep_dt.strftime("%H:%M"),
-                "ankunftszeit": arr_dt.strftime("%H:%M"),
-                "duration": duration_str,
-                "gleis": dp.get('pp', 'n/a'),
-                "zug": f"{tl.get('c', '')} {tl.get('n', '')}",
-                "_dt": dep_dt  # Hilfsfeld zum Sortieren
-            })
+            if dest_info['name'].lower() in path.lower() or destination.lower() in path.lower():
+                
+                pt = dp.get('pt', '') # Geplante Zeit: YYMMDDHHMM
+                if not pt: continue
+                
+                dep_dt = datetime.strptime(pt, "%y%m%d%H%M")
+                
+                # Nur Verbindungen in der Zukunft (ab Zeitstempel jetzt)
+                if dep_dt >= now:
+                    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"{tl.get('c', '')} {tl.get('n', '')}",
+                        "_dt": dep_dt # Hilfsfeld zum Sortieren
+                    })
 
     # 3. Sortieren und Top 3 auswählen
     found_connections.sort(key=lambda x: x['_dt'])
+    
     # 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 ---
-def ui_wrapper(dep, dest):
-    results = search_next_3_connections(dep, dest)
+
+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)
 
 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], outputs=output)
+    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()