Upload 3 files

src/app.py

@@ -99,7 +99,7 @@ async def get_route_view(route_id: str):
     all_buses = data.get("vehicles", [])
     route_buses = [v for v in all_buses if v['route'] == route_id]
     
-    # Get all stops for this route (regardless of whether there are active vehicles)
+    # Get all stops for this route
     stops_query = """
         SELECT DISTINCT
             s.stop_id,
@@ -121,72 +121,69 @@ async def get_route_view(route_id: str):
             "stop_id": str(r[0]),
             "stop_code": str(r[1]) if r[1] else None,
             "stop_name": r[2],
-            "location": {
-                "lat": r[3],
-                "lon": r[4]
-            }
+            "location": {"lat": r[3], "lon": r[4]}
         }
         for r in stops_results
     ]
     
-    # If no active vehicles, return just the stops
     if not route_buses:
-        return {
-            "route": route_id,
-            "vehicles": [],
-            "stops": stops
-        }
+        return {"route": route_id, "vehicles": [], "stops": stops}
 
-    # 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
+    # Updated query to include shape_id
     query = f"""
         SELECT 
             CAST(st.trip_id AS VARCHAR), 
             CAST(st.stop_id AS VARCHAR), 
             st.arrival_time as scheduled_time, 
-            t.trip_headsign
+            t.trip_headsign,
+            t.shape_id
         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]}")
+    db_rows = db.execute(query, trip_ids).fetchall()
 
+    # Map (trip_id, stop_id) to scheduled time
     schedule_map = {(r[0], r[1]): r[2] for r in db_rows}
-    name_map = {r[0]: r[3] for r in db_rows}
+    
+    # Map trip_id to an object containing headsign and shape_id
+    name_map = {
+        r[0]: {
+            "headsign": r[3],
+            "shape_id": r[4]
+        } 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)
 
+        # Pull details from our updated name_map
+        trip_info = name_map.get(str(bus['trip_id']), {})
+
         enriched.append({
             "number": bus['id'],
-            "name": name_map.get(str(bus['trip_id']), "Not in Schedule"), # This is the destination
+            "name": trip_info.get("headsign", "Not in Schedule"),
             "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'])
+            "delay_mins": raw_delay_mins,
+            "fullness": translate_occupancy(bus['occupancy']),
+            "shape_id": trip_info.get("shape_id") # Bonus feature ready!
         })
 
     return {
@@ -521,6 +518,32 @@ async def get_nearby_context(lat: float, lon: float):
         ]
     }
 
+@app.get("/api/shapes/{shape_id}")
+async def get_route_shape(shape_id: str):
+    """
+    Returns the ordered list of lat/lon coordinates for a specific route shape.
+    """
+    try:
+        # Query ordered by sequence to ensure the line draws correctly
+        query = """
+            SELECT shape_pt_lat, shape_pt_lon
+            FROM shapes
+            WHERE CAST(shape_id AS VARCHAR) = ?
+            ORDER BY shape_pt_sequence ASC
+        """
+        results = db.execute(query, [shape_id]).fetchall()
+        
+        # Format for Leaflet: [[lat, lon], [lat, lon], ...]
+        path = [[r[0], r[1]] for r in results]
+        
+        return {
+            "status": "success",
+            "shape_id": shape_id,
+            "coordinates": path
+        }
+    except Exception as e:
+        return {"status": "error", "message": str(e)}
+
 if __name__ == "__main__":
     import uvicorn # type: ignore
     # Start the server

src/db_manager.py

@@ -14,35 +14,41 @@ DB_PATH = str(Path(__file__).parent / "ttc_gtfs.duckdb")
 STATIC_DIR = str(Path(__file__).parent.parent / "static")
 
 def init_db():
-    """
-    Connects to DuckDB and imports the GTFS-Static data from the static/ directory.
-    """
-    # 1. Connect to DuckDB (creates the file if it doesn't exist)
     con = duckdb.connect(DB_PATH)
     
-    # 2. Check if the database is already populated
-    tables = con.execute("SHOW TABLES").fetchall()
-    if ('stop_times',) in tables:
-        print("--- Database already exists and is populated ---")
+    # 1. Check for 'shapes' specifically
+    tables = [t[0] for t in con.execute("SHOW TABLES").fetchall()]
+    
+    # If all core tables including shapes exist, skip the import
+    if all(t in tables for t in ["routes", "trips", "stops", "stop_times", "shapes"]):
+        print("--- Database fully populated (including shapes) ---")
         return con
 
-    print("--- Initializing DuckDB: Importing CSVs from /static ---")
+    print("--- Initializing/Updating DuckDB: Importing CSVs ---")
     
-    # Core GTFS files we need for the rework
-    files = ["routes.txt", "trips.txt", "stops.txt", "stop_times.txt"]
+    # Updated files list to include the missing shapes
+    files = ["routes.txt", "trips.txt", "stops.txt", "stop_times.txt", "shapes.txt"]
     
     for f in files:
         file_path = Path(STATIC_DIR) / f
         table_name = f.replace(".txt", "")
         
         if file_path.exists():
-            print(f"Loading {f} into table '{table_name}'...")
-            # 'read_csv_auto' automatically detects headers and data types
-            # Use absolute path for DuckDB
+            print(f"Importing {f} into table '{table_name}'...")
             abs_file_path = str(file_path.resolve())
-            con.execute(f"CREATE TABLE {table_name} AS SELECT * FROM read_csv_auto('{abs_file_path}')")
+            
+            # Use 'CREATE OR REPLACE' to overwrite existing tables without crashing
+            con.execute(f"CREATE OR REPLACE TABLE {table_name} AS SELECT * FROM read_csv_auto('{abs_file_path}')")
         else:
-            print(f"Error: {file_path} not found! Please ensure it is in the static/ folder.")
+            print(f"Error: {file_path} not found!")
+        
+    # Add this inside init_db in db_manager.py after the file import loop
+    print("--- Creating Indexes for Performance ---")
+    # This speeds up the /api/shapes/{shape_id} endpoint significantly
+    con.execute("CREATE INDEX IF NOT EXISTS idx_shape_id ON shapes (shape_id)")
+
+    # While you're at it, indexing trip_id in stop_times speeds up your arrival logic
+    con.execute("CREATE INDEX IF NOT EXISTS idx_stop_times_trip_id ON stop_times (trip_id)")
 
     print("--- Database Import Complete ---")
     return con

src/ttc_gtfs.duckdb

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:5eec5ac01f4d0f0dcd888097054dc7d4e4b849ecbe68012c0c8eb54a4e941d8f
-size 53751808
+oid sha256:77d950fba457220526e7c2bc2bea0a8d12fac55674ee1b576236d2a7dcd332b8
+size 122957824