Upload app.py

app.py

@@ -0,0 +1,388 @@
+from datetime import datetime # type: ignore
+import sys # type: ignore
+from pathlib import Path
+
+# Add parent directory to path to allow imports from api/
+sys.path.insert(0, str(Path(__file__).parent.parent))
+# Add src directory to path to allow imports from same directory
+sys.path.insert(0, str(Path(__file__).parent))
+
+from api.bus_cache import AsyncBusCache # type: ignore
+from api.utils import hms_to_seconds, get_service_day_start_ts, translate_occupancy # type: ignore
+from db_manager import init_db # type: ignore
+from dotenv import load_dotenv # type: ignore
+from fastapi import FastAPI, HTTPException # type: ignore
+from fastapi.middleware.cors import CORSMiddleware # type: ignore
+
+load_dotenv()
+
+ttc_cache = AsyncBusCache(ttl=20)
+
+# Initialize database connection globally
+db = init_db()
+
+app = FastAPI(title="WheresMyBus v2.0 API")
+
+# Setup CORS for your React frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], # In production, use your actual React URL
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@app.get("/")
+async def health_check():
+    """Simple health check endpoint"""
+    return "backend is running"
+
+@app.get("/api/vehicles")
+async def get_vehicles():
+    data = await ttc_cache.get_data()
+    vehicles = data.get("vehicles", [])
+    return {
+        "status": "success",
+        "count": len(vehicles),
+        "vehicles": vehicles
+    }
+
+@app.get("/api/routes")
+async def get_all_routes():
+    """
+    Returns a complete list of TTC routes with their display names and colors.
+    """
+    try:
+        # Run the query against DuckDB
+        # We handle missing colors by providing defaults (TTC Red: #FF0000)
+        query = """
+            SELECT 
+                route_id, 
+                route_short_name, 
+                route_long_name, 
+                COALESCE(route_color, 'FF0000') as route_color,
+                COALESCE(route_text_color, 'FFFFFF') as route_text_color
+            FROM routes 
+            ORDER BY 
+                CASE 
+                    WHEN CAST(route_short_name AS VARCHAR) ~ '^[0-9]+$' THEN CAST(route_short_name AS INTEGER) 
+                    ELSE 999 
+                END, 
+                route_short_name;
+        """
+        
+        results = db.execute(query).fetchall()
+        
+        # Convert to a clean list of dictionaries
+        route_list = [
+            {
+                "id": r[0],
+                "number": r[1],
+                "name": r[2],
+                "color": f"#{r[3]}",
+                "text_color": f"#{r[4]}"
+            }
+            for r in results
+        ]
+        
+        return {
+            "status": "success",
+            "count": len(route_list),
+            "routes": route_list
+        }
+        
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
+@app.get("/api/routes/{route_id}")
+async def get_route_view(route_id: str):
+    data = await ttc_cache.get_data()
+    all_buses = data.get("vehicles", [])
+    route_buses = [v for v in all_buses if v['route'] == route_id]
+    
+    if not route_buses:
+        return {"route": route_id, "vehicles": []}
+
+    # IMPORTANT: Cast Trip IDs to strings to ensure they match the DB
+    trip_ids = [str(v['trip_id']) for v in route_buses]
+    placeholders = ','.join(['?'] * len(trip_ids))
+    
+    # We use CAST(? AS VARCHAR) to force DuckDB to match strings to strings
+    query = f"""
+        SELECT 
+            CAST(st.trip_id AS VARCHAR), 
+            CAST(st.stop_id AS VARCHAR), 
+            st.arrival_time as scheduled_time, 
+            t.trip_headsign
+        FROM stop_times st
+        JOIN trips t ON CAST(st.trip_id AS VARCHAR) = CAST(t.trip_id AS VARCHAR)
+        WHERE CAST(st.trip_id AS VARCHAR) IN ({placeholders})
+    """
+    db_rows = db.execute(query, trip_ids).fetchall()
+    
+    # Check if we got ANYTHING back from the DB
+    if not db_rows:
+        print(f"DEBUG: No matches in DB for Trip IDs: {trip_ids[:3]}")
+
+    schedule_map = {(r[0], r[1]): r[2] for r in db_rows}
+    name_map = {r[0]: r[3] for r in db_rows}
+
+    service_day_ts = get_service_day_start_ts()
+    enriched = []
+
+    for bus in route_buses:
+        # Default delay is 0 if no prediction exists
+        raw_delay_mins = 0
+        
+        pred_time = bus.get('predicted_time')
+        stop_id = bus.get('next_stop_id')
+        
+        if pred_time and stop_id:
+            sched_hms = schedule_map.get((str(bus['trip_id']), str(stop_id)))
+            if sched_hms:
+                # DELAY = SCHEDULED - PREDICTED (negative = late, positive = early)
+                # Handle GTFS times >= 24 hours (next day)
+                h, m, s = map(int, sched_hms.split(':'))
+                extra_days = h // 24
+                plan_ts = service_day_ts + (extra_days * 86400) + hms_to_seconds(sched_hms)
+                raw_delay_mins = round((plan_ts - pred_time) / 60)
+
+        enriched.append({
+            "number": bus['id'],
+            "name": name_map.get(str(bus['trip_id']), "Not in Schedule"), # This is the destination
+            "location": {"lat": bus['lat'], "lon": bus['lon']},
+            "delay_mins": raw_delay_mins, # Actual integer: 5 = 5m late, -2 = 2m early
+            "fullness": translate_occupancy(bus['occupancy'])
+        })
+
+    return {
+        "route": route_id,
+        "count": len(enriched),
+        "vehicles": enriched
+    }
+
+@app.get("/api/vehicles/{vehicle_id}")
+async def get_vehicle_view(vehicle_id: str):
+    # 1. Pull latest from cache
+    data = await ttc_cache.get_data()
+    vehicles = data.get("vehicles", [])
+    
+    # 2. Find this specific bus in the list
+    bus = next((v for v in vehicles if str(v['id']) == vehicle_id), None)
+    
+    if not bus:
+        raise HTTPException(status_code=404, detail="Vehicle not active or not found")
+
+    trip_id = str(bus['trip_id'])
+    next_stop_id = bus.get('next_stop_id')
+    predicted_time = bus.get('predicted_time')
+
+    # 3. Handshake with Database (Cast to VARCHAR to avoid type errors)
+    # We get the destination name and the specific scheduled arrival time
+    destination = "Not in Schedule"
+    delay_mins = 0
+    
+    if next_stop_id:
+        query = """
+            SELECT 
+                t.trip_headsign, 
+                st.arrival_time as scheduled_time
+            FROM trips t
+            JOIN stop_times st ON CAST(t.trip_id AS VARCHAR) = CAST(st.trip_id AS VARCHAR)
+            WHERE CAST(t.trip_id AS VARCHAR) = ? 
+              AND CAST(st.stop_id AS VARCHAR) = ?
+            LIMIT 1
+        """
+        row = db.execute(query, [trip_id, str(next_stop_id)]).fetchone()
+        
+        if row:
+            destination = row[0]
+            scheduled_hms = row[1]
+            
+            # DELAY = SCHEDULED - PREDICTED (negative = late, positive = early)
+            if predicted_time:
+                service_day_ts = get_service_day_start_ts()
+                # Handle GTFS times >= 24 hours (next day)
+                h, m, s = map(int, scheduled_hms.split(':'))
+                extra_days = h // 24
+                plan_ts = service_day_ts + (extra_days * 86400) + hms_to_seconds(scheduled_hms)
+                delay_mins = round((plan_ts - predicted_time) / 60)
+    else:
+        # If no next_stop_id, try to get destination from trip_id only
+        query = """
+            SELECT trip_headsign
+            FROM trips
+            WHERE CAST(trip_id AS VARCHAR) = ?
+            LIMIT 1
+        """
+        row = db.execute(query, [trip_id]).fetchone()
+        if row:
+            destination = row[0]
+
+    return {
+        "vehicle_number": vehicle_id,
+        "route_id": bus['route'],
+        "name": destination,
+        "location": {
+            "lat": bus['lat'],
+            "lon": bus['lon']
+        },
+        "delay_mins": delay_mins,
+        "fullness": translate_occupancy(bus['occupancy']),
+        "trip_id": trip_id
+    }
+
+@app.get("/api/stop/{stop_code}")
+async def get_stop_view(stop_code: str):
+    # 1. Translate Pole Number to Database ID
+    stop_info = db.execute("SELECT stop_id, stop_name, stop_lat, stop_lon FROM stops WHERE CAST(stop_code AS VARCHAR) = ? LIMIT 1", [str(stop_code)]).fetchone()
+    if not stop_info:
+        return {"error": "Stop code not found"}
+    
+    target_id = str(stop_info[0])
+    stop_name = stop_info[1]
+    stop_lat = stop_info[2]
+    stop_lon = stop_info[3]
+
+    # 2. Get the Cache structure (dict with vehicles, predictions, alerts)
+    cached_data = await ttc_cache.get_data()
+    vehicles_list = cached_data.get("vehicles", [])
+    predictions = cached_data.get("predictions", {})
+    
+    # Build vehicles map for quick lookup
+    vehicles = {str(v['trip_id']): v for v in vehicles_list}
+
+    from datetime import timezone
+    now = datetime.now(timezone.utc).timestamp()
+    two_hours_out = now + 7200
+    arrivals = []
+
+    # 3. Search the FULL itineraries for our target_id
+    for trip_id, itinerary in predictions.items():
+        if target_id in itinerary:
+            pred_time = itinerary[target_id]
+            
+            # Only include if the bus hasn't passed the stop yet and is within 2 hours
+            if now <= pred_time <= two_hours_out:
+                
+                # 4. Handshake with DB for destination and schedule
+                query = """
+                    SELECT t.trip_headsign, st.arrival_time as scheduled_time, r.route_short_name
+                    FROM trips t
+                    JOIN stop_times st ON CAST(t.trip_id AS VARCHAR) = CAST(st.trip_id AS VARCHAR)
+                    JOIN routes r ON t.route_id = r.route_id
+                    WHERE CAST(t.trip_id AS VARCHAR) = ? AND CAST(st.stop_id AS VARCHAR) = ?
+                    LIMIT 1
+                """
+                row = db.execute(query, [trip_id, target_id]).fetchone()
+
+                if row:
+                    # Find the actual bus for fullness (if it's on the road)
+                    bus = vehicles.get(trip_id)
+                    
+                    # DELAY = SCHEDULED - PREDICTED (negative = late, positive = early)
+                    service_day_ts = get_service_day_start_ts()
+                    scheduled_hms = row[1]
+                    # Handle GTFS times >= 24 hours (next day)
+                    h, m, s = map(int, scheduled_hms.split(':'))
+                    extra_days = h // 24
+                    plan_ts = service_day_ts + (extra_days * 86400) + hms_to_seconds(scheduled_hms)
+                    
+                    arrivals.append({
+                        "route": row[2],
+                        "destination": row[0],
+                        "eta_mins": round((pred_time - now) / 60),
+                        "delay_mins": round((plan_ts - pred_time) / 60),
+                        "fullness": translate_occupancy(bus['occupancy']) if bus else "Unknown",
+                        "vehicle_id": bus['id'] if bus else "In Transit"
+                    })
+
+    arrivals.sort(key=lambda x: x['eta_mins'])
+    return {
+        "stop_name": stop_name,
+        "stop_code": stop_code,
+        "location": {
+            "lat": stop_lat,
+            "lon": stop_lon
+        },
+        "arrivals": arrivals
+    }
+
+@app.get("/api/alerts")
+async def get_all_alerts():
+    """
+    Returns every active service alert for the entire TTC network.
+    """
+    from datetime import timezone
+    data = await ttc_cache.get_data()
+    return {
+        "timestamp": datetime.now(timezone.utc).timestamp(),
+        "count": len(data["alerts"]),
+        "alerts": data["alerts"]
+    }
+
+@app.get("/api/alerts/{route_id}")
+async def get_alerts_for_route(route_id: str):
+    data = await ttc_cache.get_data()
+    alerts = data.get("alerts", {})
+    route_alerts = alerts.get(route_id, [])
+    
+    if not route_alerts:
+        return {
+            "route_id": route_id,
+            "count": 0,
+            "alerts": "No alerts"
+        }
+    
+    return {
+        "route_id": route_id,
+        "count": len(route_alerts),
+        "alerts": route_alerts
+    }
+
+@app.get("/api/nearby")
+async def get_nearby_context(lat: float, lon: float):
+    # Bounding box approximation for ~500m radius (fast, no Haversine needed)
+    # At Toronto's latitude (~43.6°): 1° lat ≈ 111km, 1° lon ≈ 55.4km
+    # For 500m: lat_range = 0.0045°, lon_range ≈ 0.0072°
+    lat_range = 0.0045  # ~500m in latitude (constant globally)
+    lon_range = 0.0072  # ~500m in longitude at Toronto's latitude
+
+    # 1. Find all stops within the bounding box
+    query_stops = """
+        SELECT stop_id, stop_code, stop_name, stop_lat, stop_lon
+        FROM stops
+        WHERE stop_lat BETWEEN ? AND ?
+          AND stop_lon BETWEEN ? AND ?
+    """
+    stops = db.execute(query_stops, [lat - lat_range, lat + lat_range, lon - lon_range, lon + lon_range]).fetchall()
+    
+    stop_ids = [str(s[0]) for s in stops]
+    if not stop_ids:
+        return {"stops": [], "routes": []}
+
+    # 2. Find all unique routes serving these specific stops
+    placeholders = ','.join(['?'] * len(stop_ids))
+    query_routes = f"""
+        SELECT DISTINCT r.route_id, r.route_short_name, r.route_long_name, r.route_color
+        FROM routes r
+        JOIN trips t ON r.route_id = t.route_id
+        JOIN stop_times st ON t.trip_id = st.trip_id
+        WHERE CAST(st.stop_id AS VARCHAR) IN ({placeholders})
+    """
+    routes = db.execute(query_routes, stop_ids).fetchall()
+
+    return {
+        "stops": [
+            {"id": s[0], "code": s[1], "name": s[2], "lat": s[3], "lon": s[4]} 
+            for s in stops
+        ],
+        "routes": [
+            {"id": r[0], "short_name": r[1], "long_name": r[2], "color": f"#{r[3]}"} 
+            for r in routes
+        ]
+    }
+
+if __name__ == "__main__":
+    import uvicorn # type: ignore
+    # Start the server
+    uvicorn.run(app, host="0.0.0.0", port=7860)