Update app.py

app.py

@@ -14,146 +14,143 @@ def get_station_info(pattern, client_id, api_key):
         station = root.find('station')
         if station is not None:
             return {'name': station.get('name'), 'eva': station.get('eva')}
-    except:
-        return None
+    except Exception as e:
+        print(f"Error fetching station: {e}")
     return None
 
-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."""
+def get_journey_details(trip_id, dest_eva, client_id, api_key):
+    """Holt Ankunftszeit am Ziel-Bahnhof via Trip-ID."""
     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
+        if response.status_code != 200: return None
+        root = ET.fromstring(response.content)
+        
+        # Suche nach dem Stop, der die Ziel-EVA hat
+        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') # Geplante Ankunftszeit
+    except: pass
     return None
 
-def calculate_duration(dep_raw, arr_raw):
-    """Berechnet die Reisedauer aus zwei Zeitstempeln (YYMMDDHHMM)."""
+def calculate_duration(dep_str, arr_str):
+    fmt = "%y%m%d%H%M"
     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"
-
-def search_connections(departure, destination, client_id, api_key):
-    if not all([departure, destination, client_id, api_key]):
-        return "❌ Bitte alle Felder ausfüllen.", []
+        diff = datetime.strptime(arr_str, fmt) - datetime.strptime(dep_str, fmt)
+        hours, remainder = divmod(diff.total_seconds(), 3600)
+        return f"{int(hours)}h {int(remainder // 60)}min"
+    except: return "n/a"
 
-    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 "❌ Bahnhof nicht gefunden. Bitte Schreibweise prüfen.", []
+def get_next_3_connections(departure_query, destination_query, client_id, api_key):
+    # 1. Bahnhofs-IDs holen
+    dep_info = get_station_info(departure_query, client_id, api_key)
+    dest_info = get_station_info(destination_query, client_id, api_key)
+    
+    if not dep_info: return None, f"Startbahnhof '{departure_query}' nicht gefunden."
+    if not dest_info: return None, f"Zielbahnhof '{destination_query}' nicht gefunden."
 
     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
+    
+    # Wir suchen in den nächsten 10 Stunden (um sicher 3 zu finden, auch in der Nacht)
+    for hour_offset in range(10):
+        if len(found_conns) >= 3: break
         
         search_time = now + timedelta(hours=hour_offset)
-        datum = search_time.strftime("%y%m%d")
-        stunde = search_time.strftime("%H")
+        date_str = search_time.strftime("%y%m%d")
+        hour_str = search_time.strftime("%H")
         
-        url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{dep_info['eva']}/{datum}/{stunde}"
+        url = f"https://apis.deutschebahn.com/db-api-marketplace/apis/timetables/v1/plan/{dep_info['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:
-                continue
+            res = requests.get(url, headers=headers, timeout=10)
+            if res.status_code != 200: continue
+            root = ET.fromstring(res.content)
             
-            root = ET.fromstring(response.content)
             for s in root.findall('.//s'):
                 dp = s.find('dp')
-                if dp is None:
-                    continue
+                if dp is None: continue
                 
+                # Check ob Ziel in der Route (ppth) vorkommt
                 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")
+                dest_name = dest_info['name']
+                
+                # Filter: Ist das Ziel im Fahrtverlauf?
+                if dest_name.lower() in path.lower() or destination_query.lower() in path.lower():
+                    dep_time_raw = dp.get('pt')
+                    dep_dt = datetime.strptime(dep_time_raw, "%y%m%d%H%M")
                     
-                    if dep_dt >= (now - timedelta(minutes=2)):
+                    # Nur zukünftige Züge (mit 5 Min Puffer)
+                    if dep_dt >= (now - timedelta(minutes=5)):
                         trip_id = s.get('id')
-                        arr_raw = get_arrival_info(trip_id, dest_info['eva'], client_id, api_key)
+                        arr_time_raw = get_journey_details(trip_id, dest_info['eva'], client_id, api_key)
                         
-                        if arr_raw:
+                        if arr_time_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),
+                                "ankunft": datetime.strptime(arr_time_raw, "%y%m%d%H%M").strftime("%H:%M"),
+                                "dauer": calculate_duration(dep_time_raw, arr_time_raw),
                                 "gleis": dp.get('pp', '-'),
-                                "start": dep_info['name'],
-                                "ziel": dest_info['name'],
+                                "startort": dep_info['name'],
+                                "zielort": dest_info['name'],
                                 "_dt": dep_dt
                             })
-                            if len(found_conns) >= 3:
-                                break
-        except:
-            continue
+                            if len(found_conns) >= 3: break
+        except: continue
 
     found_conns.sort(key=lambda x: x['_dt'])
-    return None, found_conns[:3]
+    return found_conns[:3], None
 
-def main(departure, destination, client_id, api_key):
-    err, conns = search_connections(departure, destination, client_id, api_key)
+def process(dep, dest, cid, akey):
+    data, error = get_next_3_connections(dep, dest, cid, akey)
     
-    if err:
-        return err, json.dumps({"error": err})
-    if not conns:
-        return "Keine Direktverbindungen gefunden.", "[]"
+    if error:
+        return f"### ❌ Fehler\n{error}", json.dumps({"error": error}, indent=2)
     
+    if not data:
+        return "### ℹ️ Keine direkten Verbindungen gefunden.", "[]"
+
     # JSON Output (ohne internes Sortierfeld)
-    clean_json = [{k: v for k, v in c.items() if k != "_dt"} for c in conns]
+    json_clean = [{k: v for k, v in c.items() if k != "_dt"} for c in data]
     
-    # Markdown Tabelle (Flat & Professional)
-    md = f"### 🚆 {conns[0]['start']} → {conns[0]['ziel']}\n\n"
+    # Markdown Table
+    md = f"### 🚆 {data[0]['startort']} → {data[0]['zielort']}\n\n"
     md += "| Zug | Abfahrt | Ankunft | Dauer | Gleis |\n"
     md += "|:---|:---|:---|:---|:---|\n"
-    for c in clean_json:
+    for c in json_clean:
         md += f"| **{c['zug']}** | {c['abfahrt']} | {c['ankunft']} | {c['dauer']} | {c['gleis']} |\n"
     
     md += f"\n\n*Abfragezeitpunkt: {datetime.now().strftime('%H:%M')}*"
     
-    return md, clean_json
+    return md, json_clean
 
 # --- Gradio UI ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🚄 DB Timetable Service")
+with gr.Blocks(theme=gr.themes.Soft(), title="DB Timetable Pro") as demo:
+    gr.Markdown("# 🚄 DB Timetable Professional")
+    
     with gr.Row():
-        cid = gr.Textbox(label="Client ID", type="password")
-        akey = gr.Textbox(label="API Key", type="password")
+        cid = gr.Textbox(label="Client ID", type="password", value="")
+        akey = gr.Textbox(label="API Key", type="password", value="")
+    
     with gr.Row():
-        start = gr.Textbox(label="Start", placeholder="z.B. Berlin Hbf")
-        ziel = gr.Textbox(label="Ziel", placeholder="z.B. Hamburg Hbf")
+        start = gr.Textbox(label="Von", placeholder="z.B. Berlin Hbf")
+        ziel = gr.Textbox(label="Nach", placeholder="z.B. Hamburg Hbf")
     
     btn = gr.Button("Nächste 3 Verbindungen suchen", variant="primary")
     
-    output_md = gr.Markdown()
-    output_json = gr.JSON(label="JSON Result")
+    with gr.Tabs():
+        with gr.TabItem("📱 Verbindung"):
+            md_out = gr.Markdown("Ergebnisse erscheinen hier...")
+        with gr.TabItem("💻 JSON"):
+            json_out = gr.JSON()
 
-    btn.click(main, [start, ziel, cid, akey], [output_md, output_json])
+    btn.click(process, [start, ziel, cid, akey], [md_out, json_out])
 
 if __name__ == "__main__":
     demo.launch()