Update app.py

app.py

@@ -3,124 +3,140 @@ import requests
 from datetime import datetime, timedelta
 import xml.etree.ElementTree as ET
 import json
-import os
-
-api_key=os.environ.get("api_key")
-client_id=os.environ.get("client_id")
 
 def get_station_info(pattern, client_id, api_key):
+    """Ermittelt EVA-Nummer und offiziellen Namen."""
     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)
         station = root.find('station')
-        return {'name': station.get('name'), 'eva': station.get('eva')} if station is not None else None
-    except: return None
+        if station is not None:
+            return {'name': station.get('name'), 'eva': station.get('eva')}
+    except Exception:
+        return None
+    return None
 
-def get_arrival_time(trip_id, dest_name, client_id, api_key):
-    """Ruft die Ankunftszeit für einen spezifischen Zug am Zielbahnhof ab."""
-    url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/journey/{trip_id}"
+def fetch_timetable_hour(eva, date_str, hour_str, client_id, api_key):
+    """Ruft den Fahrplan für eine bestimmte Stunde ab."""
+    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'}
     try:
         response = requests.get(url, headers=headers, timeout=10)
-        if response.status_code != 200: return None
-        root = ET.fromstring(response.content)
-        # Suche im Fahrtverlauf nach dem Zielbahnhof
-        for stop in root.findall('.//s'):
-            if dest_name.lower() in stop.get('static_name', '').lower():
-                ar = stop.find('ar')
-                if ar is not None: return ar.get('pt') # Geplante Ankunftszeit
-    except: pass
+        if response.status_code == 200:
+            return ET.fromstring(response.content)
+    except Exception:
+        pass
     return None
 
-def calculate_duration(dep_str, arr_str):
-    """Berechnet Dauer in Stunden und Minuten."""
-    fmt = "%y%m%d%H%M"
-    dep_dt = datetime.strptime(dep_str, fmt)
-    arr_dt = datetime.strptime(arr_str, fmt)
-    diff = arr_dt - dep_dt
-    hours, remainder = divmod(diff.seconds, 3600)
-    minutes = remainder // 60
-    return f"{hours}h {minutes}min"
+def get_connections(departure, destination, client_id, api_key):
+    """Sucht die nächsten 3 Verbindungen ab jetzt."""
+    if not all([departure, destination, client_id, api_key]):
+        return None, "❌ Bitte alle Felder ausfüllen."
 
-def get_next_3_connections(departure, destination, client_id, api_key):
     dep_info = get_station_info(departure, client_id, api_key)
     dest_info = get_station_info(destination, client_id, api_key)
-    if not dep_info or not dest_info: return None, "Bahnhof nicht gefunden."
+    
+    if not dep_info or not dest_info:
+        return None, "❌ Bahnhof nicht gefunden. Bitte Namen prüfen."
 
     now = datetime.now()
-    conns = []
+    found_connections = []
     
-    # Suche über die nächsten Stunden
-    for hour_offset in range(5): # Größeres Fenster um sicher 3 zu finden
-        t = now + timedelta(hours=hour_offset)
-        url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{dep_info['eva']}/{t.strftime('%y%m%d')}/{t.strftime('%H')}"
-        headers = {'DB-Client-Id': client_id, 'DB-Api-Key': api_key, 'accept': 'application/xml'}
+    # Suche über 3 Stunden-Slots hinweg (aktuelle + nächste zwei)
+    for hour_offset in range(3):
+        search_time = now + timedelta(hours=hour_offset)
+        datum = search_time.strftime("%y%m%d")
+        stunde = search_time.strftime("%H")
         
-        res = requests.get(url, headers=headers, timeout=10)
-        if res.status_code != 200: continue
-        root = ET.fromstring(res.content)
-        
-        for s in root.findall('.//s'):
-            dp = s.find('dp')
+        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
             
             path = dp.get('ppth', '')
             if dest_info['name'].lower() in path.lower() or destination.lower() in path.lower():
-                dep_time_raw = dp.get('pt')
-                if not dep_time_raw or datetime.strptime(dep_time_raw, "%y%m%d%H%M") < now: continue
+                pt = dp.get('pt', '')
+                if not pt: continue
                 
-                # Jetzt Ankunftszeit via Journey-API ermitteln
-                trip_id = s.get('id')
-                arr_time_raw = get_arrival_time(trip_id, dest_info['name'], client_id, api_key)
+                dep_dt = datetime.strptime(pt, "%y%m%d%H%M")
                 
-                if arr_time_raw:
-                    conns.append({
-                        "zug": f"{s.find('tl').get('c')}{s.find('tl').get('n')}",
-                        "abfahrt": datetime.strptime(dep_time_raw, "%y%m%d%H%M").strftime("%H:%M"),
-                        "ankunft": datetime.strptime(arr_time_raw, "%y%m%d%H%M").strftime("%H:%M"),
-                        "dauer": calculate_duration(dep_time_raw, arr_time_raw),
+                if dep_dt >= now:
+                    tl = train.find('tl')
+                    found_connections.append({
+                        "startort": dep_info['name'],
+                        "zielort": dest_info['name'],
+                        "abfahrtszeit": dep_dt.strftime("%H:%M"),
+                        "datum": dep_dt.strftime("%d.%m.%Y"),
                         "gleis": dp.get('pp', '-'),
-                        "_dt": datetime.strptime(dep_time_raw, "%y%m%d%H%M")
+                        "zug": f"{tl.get('c', '')} {tl.get('n', '')}",
+                        "_dt": dep_dt
                     })
-        if len(conns) >= 3: break
 
-    conns.sort(key=lambda x: x['_dt'])
-    return conns[:3], None
+    found_connections.sort(key=lambda x: x['_dt'])
+    return found_connections[:3], None
 
-def format_output(dep, dest, client_id, api_key):
-    data, err = get_next_3_connections(dep, dest, client_id, api_key)
-    if err: return err, json.dumps({"error": err})
+def format_markdown(connections):
+    """Erstellt eine Smartphone-optimierte Markdown-Ansicht."""
+    if not connections:
+        return "### ℹ️ Keine Verbindungen gefunden\nIn den nächsten 3 Stunden wurden keine Direktverbindungen gefunden."
     
-    # JSON Output
-    clean_json = [{k: v for k, v in c.items() if k != "_dt"} for c in data]
+    md = f"## 🚆 {connections[0]['startort']} → {connections[0]['zielort']}\n"
+    md += f"*{datetime.now().strftime('%H:%M')} Uhr Stand*\n\n"
     
-    # Markdown Table Output (Smartphone optimiert)
-    md = f"### 🚆 {dep.upper()} → {dest.upper()}\n\n"
-    md += "| Zug | Ab | An | Dauer | Gl. |\n"
-    md += "|:---|:---|:---|:---|:---|\n"
-    for c in clean_json:
-        md += f"| **{c['zug']}** | {c['abfahrt']} | {c['ankunft']} | {c['dauer']} | {c['gleis']} |\n"
+    for i, c in enumerate(connections, 1):
+        md += f"### {i}. {c['abfahrtszeit']} Uhr\n"
+        md += f"**{c['zug']}**  \n"
+        md += f"Gleis: **{c['gleis']}** | Datum: {c['datum']}\n"
+        md += "---\n" # Trennlinie für bessere Lesbarkeit auf dem Handy
     
-    md += f"\n\n*Stand: {datetime.now().strftime('%H:%M')}*"
-    
-    return md, clean_json
+    return md
 
-# --- Interface ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚄 DB Timetable Pro")
+def main_interface(dep, dest, cid, akey):
+    conns, error = get_connections(dep, dest, cid, akey)
+    
+    if error:
+        return error, json.dumps({"error": error}, indent=2)
+    
+    # JSON-Bereinigung (internes Sortierfeld entfernen)
+    clean_json = []
+    for c in conns:
+        clean_json.append({k: v for k, v in c.items() if k != "_dt"})
+    
+    md_output = format_markdown(clean_json)
+    json_output = json.dumps(clean_json, indent=4, ensure_ascii=False)
+    
+    return md_output, json_output
 
+# --- Gradio UI ---
+with gr.Blocks(title="DB Mobile Fahrplan", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 📱 DB Quick-Check")
+    
+    with gr.Accordion("⚙️ API-Konfiguration (Hier klicken)", open=False):
+        cid_input = gr.Textbox(label="DB Client ID", type="password")
+        akey_input = gr.Textbox(label="DB API Key", type="password")
+        
     with gr.Row():
-        start = gr.Textbox(label="Start", placeholder="z.B. Köln Hbf")
-        ziel = gr.Textbox(label="Ziel", placeholder="z.B. Berlin Hbf")
+        dep_input = gr.Textbox(label="Von", placeholder="z.B. Berlin", scale=2)
+        dest_input = gr.Textbox(label="Nach", placeholder="z.B. Hamburg", scale=2)
     
-    btn = gr.Button("Verbindungen finden", variant="primary")
+    btn = gr.Button("🔍 Verbindungen suchen", variant="primary")
     
-    display = gr.Markdown()
-    js_out = gr.JSON(label="JSON Daten")
-
-    btn.click(format_output, [start, ziel,], [display, js_out])
+    with gr.Tabs():
+        with gr.TabItem("📱 Ansicht"):
+            md_display = gr.Markdown("Geben Sie Start und Ziel ein und drücken Sie Suchen.")
+        with gr.TabItem("💻 JSON"):
+            json_display = gr.Code(label="API Response", language="json")
+            
+    btn.click(
+        fn=main_interface, 
+        inputs=[dep_input, dest_input, cid_input, akey_input], 
+        outputs=[md_display, json_display]
+    )
 
 if __name__ == "__main__":
     demo.launch()