Create app.py

app.py

@@ -0,0 +1,97 @@
+# app.py
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Dict, Any
+import joblib, os, time, math
+import numpy as np
+
+APP_PORT = int(os.environ.get("PORT", 7860))  # HF maps to 7860
+
+app = FastAPI(title="Transit Tracker API")
+
+# In-memory store for vehicles
+VEHICLES: Dict[str, Dict[str, Any]] = {}
+
+MODEL = None
+MODEL_PATH = "models/model.joblib"
+
+# -- Utilities
+def haversine(lat1, lon1, lat2, lon2):
+    # returns meters
+    R = 6371000
+    phi1, phi2 = math.radians(lat1), math.radians(lat2)
+    dphi = math.radians(lat2-lat1)
+    dlambda = math.radians(lon2-lon1)
+    a = math.sin(dphi/2)**2 + math.cos(phi1)*math.cos(phi2)*math.sin(dlambda/2)**2
+    return R * 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))
+
+def load_model():
+    global MODEL
+    if MODEL is None:
+        if not os.path.exists(MODEL_PATH):
+            raise RuntimeError("Model file not found: " + MODEL_PATH)
+        MODEL = joblib.load(MODEL_PATH)
+    return MODEL
+
+# -- Request models
+class VehicleUpdate(BaseModel):
+    vehicle_id: str
+    lat: float
+    lon: float
+    speed: float = 0.0      # meters/sec
+    bearing: float = None
+    timestamp: str = None   # ISO
+
+class PredictRequest(BaseModel):
+    distance_to_stop_m: float
+    speed_mps: float = 3.0
+    timestamp_iso: str = None  # optional
+
+# -- Endpoints
+@app.get("/health")
+def health():
+    ok = os.path.exists(MODEL_PATH)
+    return {"status": "ok" if ok else "model-missing", "model_path": MODEL_PATH, "time": time.time()}
+
+@app.post("/vehicle/update")
+def vehicle_update(v: VehicleUpdate):
+    VEHICLES[v.vehicle_id] = {
+        "lat": v.lat,
+        "lon": v.lon,
+        "speed": v.speed,
+        "bearing": v.bearing,
+        "timestamp": v.timestamp or time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
+    }
+    return {"ok": True, "vehicle_id": v.vehicle_id}
+
+@app.get("/vehicles")
+def get_vehicles():
+    return VEHICLES
+
+@app.post("/predict")
+def predict(req: PredictRequest):
+    # safety checks
+    if req.distance_to_stop_m < 0:
+        raise HTTPException(status_code=400, detail="distance must be >= 0")
+
+    model = load_model()
+    # compute TOD features (simple UTC seconds)
+    if req.timestamp_iso:
+        try:
+            import datetime
+            dt = datetime.datetime.fromisoformat(req.timestamp_iso.replace("Z",""))
+            sec = dt.hour*3600 + dt.minute*60 + dt.second
+            dow = dt.weekday()
+        except:
+            sec = time.gmtime().tm_hour*3600
+            dow = time.gmtime().tm_wday
+    else:
+        sec = time.gmtime().tm_hour*3600 + time.gmtime().tm_min*60 + time.gmtime().tm_sec
+        dow = time.gmtime().tm_wday
+
+    tod_sin = np.sin(2*np.pi*sec/86400)
+    tod_cos = np.cos(2*np.pi*sec/86400)
+
+    X = [[float(req.distance_to_stop_m), float(req.speed_mps), float(tod_sin), float(tod_cos), int(dow)]]
+    eta_seconds = float(model.predict(X)[0])
+    return {"eta_seconds": eta_seconds, "eta_minutes": eta_seconds/60.0}