Create app.py

app.py

@@ -0,0 +1,209 @@
+# Deutsche Bahn Timetable Gradio App
+
+## app.py
+
+```python
+import gradio as gr
+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_eva_number(station_name):
+    """Wandelt Stationsnamen in EVA-Nummer um"""
+    normalized = station_name.lower().strip()
+    return STATION_EVA.get(normalized)
+
+def search_connections(departure, destination, client_id, api_key):
+    """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"
+    
+    # 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}"
+    
+    # Aktuelles Datum und Stunde
+    now = datetime.now()
+    datum = now.strftime("%y%m%d")  # YYMMDD
+    stunde = now.strftime("%H")      # HH
+    
+    # API-Aufruf
+    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)
+        
+        if response.status_code != 200:
+            return f"❌ API Fehler: {response.status_code} - {response.text[:200]}"
+        
+        # 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
+            path = dp.get('ppth', '')
+            
+            # Prüfen ob Zielort in Route enthalten ist
+            if destination.lower() in path.lower():
+                train_id = train.get('id', 'Unbekannt')
+                planned_time = dp.get('pt', '')
+                platform = dp.get('pp', 'n/a')
+                
+                # Zeit formatieren (von HHMM zu HH:MM)
+                if len(planned_time) == 4:
+                    planned_time = f"{planned_time[:2]}:{planned_time[2:]}"
+                
+                # Route formatieren
+                route = ' → '.join(path.split('|'))
+                
+                connections.append({
+                    'train': train_id,
+                    '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."
+        
+        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"
+        
+        for i, conn in enumerate(connections[:10], 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"
+        
+        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)}"
+
+# Gradio Interface erstellen
+with gr.Blocks(title="Deutsche Bahn Fahrplanauskunft", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        """
+        # 🚆 Deutsche Bahn Fahrplanauskunft
+        Finden Sie Zugverbindungen mit der DB Timetable API
+        """
+    )
+    
+    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"
+            )
+    
+    with gr.Row():
+        with gr.Column():
+            departure_input = gr.Textbox(
+                label="Abfahrtsort",
+                placeholder="z.B. Frankfurt",
+                value=""
+            )
+        with gr.Column():
+            destination_input = gr.Textbox(
+                label="Zielort",
+                placeholder="z.B. Berlin",
+                value=""
+            )
+    
+    gr.Markdown("⏰ **Abfahrtszeit:** Jetzt (automatisch)")
+    
+    search_button = gr.Button("🔍 Verbindungen suchen", variant="primary", size="lg")
+    
+    output = gr.Textbox(
+        label="Ergebnisse",
+        lines=20,
+        max_lines=30
+    )
+    
+    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")
+        """
+    )
+    
+    search_button.click(
+        fn=search_connections,
+        inputs=[departure_input, destination_input, client_id_input, api_key_input],
+        outputs=output
+    )
+
+if __name__ == "__main__":
+    demo.launch()
+```
+
+## requirements.txt
+
+```
+gradio
+requests
+```
+
+## Installation und Verwendung
+
+1. Erstellen Sie diese beiden Dateien in Ihrem Hugging Face Space
+2. Die App startet automatisch
+3. Holen Sie sich API-Zugangsdaten von [developers.deutschebahn.com](https://developers.deutschebahn.com)
+4. Geben Sie die Zugangsdaten ein und suchen Sie nach Verbindungen