github-actions[bot]
Deploy Backend to Hugging Face Space (cd6fa289779b953d2aec0e717f568ed39f702154)
1810ba0 Download main.py from ThEyAtH/EUDORA: direct link, hf CLI and curl.
- Browser
- Download file 19.2 kB
-
https://huggingface.co/spaces/ThEyAtH/EUDORA/resolve/main/main.py
- Command line
-
hf download hf://spaces/ThEyAtH/EUDORA/main.py
-
curl -L -o main.py https://huggingface.co/spaces/ThEyAtH/EUDORA/resolve/main/main.py
19.2 kB
| from dotenv import load_dotenv | |
| load_dotenv() | |
| from contextlib import asynccontextmanager | |
| import os | |
| import logging | |
| import asyncio | |
| import time | |
| from pathlib import Path | |
| import httpx | |
| from fastapi import FastAPI, Request, Query, Response, Path as FastAPIPath | |
| from fastapi.middleware.cors import CORSMiddleware | |
| from fastapi.responses import JSONResponse | |
| from slowapi import Limiter, _rate_limit_exceeded_handler | |
| from slowapi.errors import RateLimitExceeded | |
| from starlette.middleware.base import BaseHTTPMiddleware | |
| from backend.api.routes import router | |
| from backend.routing.graph_builder import build_graph | |
| from backend.signal.signal_model import SignalModel | |
| from backend.pollution.pollution_model import PollutionModel | |
| from backend.routing.traffic_enricher import TrafficEnricher | |
| from backend.trees.tree_cost import get_store | |
| from backend.trees.tree_store import load_tree_store | |
| LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO").upper() | |
| logging.basicConfig(level=getattr(logging, LOG_LEVEL, logging.INFO)) | |
| logger = logging.getLogger(__name__) | |
| LOCAL_DEV = os.getenv("EUDORA_LOCAL_DEV", "1").lower() not in {"0", "false", "no"} | |
| PROJECT_ROOT = Path(__file__).resolve().parent | |
| GRAPHML_GRAPH_PATH = PROJECT_ROOT / "indore.graphml" | |
| CANOPY_STORE_PATH = PROJECT_ROOT / "data" / "canopy_scores.json" | |
| def get_client_ip(request: Request) -> str: | |
| forwarded_for = request.headers.get("x-forwarded-for", "") | |
| if forwarded_for: | |
| return forwarded_for.split(",")[0].strip() | |
| return request.client.host if request.client else "unknown" | |
| # ββ Rate limiter ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| limiter = Limiter(key_func=get_client_ip, enabled=not LOCAL_DEV) | |
| # ββ Allowed frontend origins βββββββββββββββββββββββββββββββββββββββββββββββββ | |
| ALLOWED_ORIGINS = os.getenv( | |
| "ALLOWED_ORIGINS", | |
| "http://localhost:3000,http://localhost:5173,http://localhost:5500,http://127.0.0.1:5500,http://localhost:8000", | |
| ).split(",") | |
| ALLOWED_ORIGINS = [origin.strip() for origin in ALLOWED_ORIGINS if origin.strip()] | |
| # ββ Startup timestamp ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| _BOOT_TIME: float = 0.0 | |
| # ββ Security headers middleware βββββββββββββββββββββββββββββββββββββββββββββββ | |
| class SecurityHeadersMiddleware(BaseHTTPMiddleware): | |
| async def dispatch(self, request: Request, call_next): | |
| response = await call_next(request) | |
| response.headers["X-Content-Type-Options"] = "nosniff" | |
| response.headers["X-Frame-Options"] = "DENY" | |
| response.headers["Referrer-Policy"] = "strict-origin-when-cross-origin" | |
| response.headers["Permissions-Policy"] = "geolocation=(self), microphone=(self), camera=()" | |
| response.headers["X-XSS-Protection"] = "1; mode=block" | |
| return response | |
| # ββ Request size limiting middleware ββββββββββββββββββββββββββββββββββββββββββ | |
| MAX_REQUEST_BODY_BYTES = int(os.getenv("MAX_REQUEST_BODY_BYTES", str(10 * 1024 * 1024))) | |
| class RequestSizeLimitMiddleware(BaseHTTPMiddleware): | |
| async def dispatch(self, request: Request, call_next): | |
| content_length = request.headers.get("content-length") | |
| if content_length and int(content_length) > MAX_REQUEST_BODY_BYTES: | |
| return JSONResponse( | |
| status_code=413, | |
| content={"error": "Request body too large."}, | |
| ) | |
| return await call_next(request) | |
| # ββ Env var validation ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _validate_env_vars() -> dict[str, bool]: | |
| """Check required env vars at startup and log warnings for missing ones.""" | |
| required = { | |
| "TOMTOM_API_KEY": "TomTom traffic data β live speeds will be unavailable", | |
| "LOCATIONIQ_TOKEN": "LocationIQ geocoding β geocode proxy will return 503", | |
| "MAPTILER_KEY": "MapTiler tiles β tile proxy will return 503", | |
| "OWM_API_KEY": "OpenWeatherMap AQI β will use historical/fallback AQI", | |
| } | |
| optional = { | |
| "OLA_MAPS_KEY": "Ola Maps geocoding fallback", | |
| "GEE_PROJECT_ID": "Google Earth Engine (precomputation only)", | |
| } | |
| status = {} | |
| for var, desc in required.items(): | |
| present = bool(os.environ.get(var)) | |
| status[var] = present | |
| if not present: | |
| logger.warning("[Startup] Missing env var %s β %s", var, desc) | |
| for var, desc in optional.items(): | |
| present = bool(os.environ.get(var)) | |
| status[var] = present | |
| if not present: | |
| logger.info("[Startup] Optional env var %s not set β %s", var, desc) | |
| return status | |
| # ββ GEE initialization βββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| def _initialize_earth_engine() -> bool: | |
| """Attempt ee.Initialize() β never ee.Authenticate() on a server.""" | |
| try: | |
| import ee | |
| project_id = os.getenv("GEE_PROJECT_ID") | |
| if project_id: | |
| ee.Initialize(project=project_id) | |
| else: | |
| ee.Initialize() | |
| logger.info("[Startup] Google Earth Engine initialized.") | |
| return True | |
| except Exception as exc: | |
| logger.warning( | |
| "[Startup] GEE initialization failed (non-fatal, precomputation only): %s", | |
| exc, | |
| ) | |
| return False | |
| def _load_canopy_store() -> tuple[dict[str, float], bool]: | |
| if not CANOPY_STORE_PATH.exists(): | |
| logger.warning( | |
| "[Startup] Canopy store not found at %s; using an empty canopy store.", | |
| CANOPY_STORE_PATH, | |
| ) | |
| return {}, False | |
| store = load_tree_store(str(CANOPY_STORE_PATH)) | |
| logger.info("[Startup] Loaded canopy store from %s.", CANOPY_STORE_PATH) | |
| return store, True | |
| async def lifespan(app: FastAPI): | |
| global _BOOT_TIME | |
| _BOOT_TIME = time.time() | |
| # ββ Validate environment ββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| env_status = _validate_env_vars() | |
| # ββ GEE (non-fatal) ββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| gee_ok = _initialize_earth_engine() | |
| # ββ Graph βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| logger.info("[Startup] Building graph...") | |
| G = build_graph(filepath=str(GRAPHML_GRAPH_PATH)) | |
| canopy_store, canopy_loaded = _load_canopy_store() | |
| app.state.canopy_store = canopy_store | |
| get_store() | |
| # ββ Signal model ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| logger.info("[Startup] Attaching signal weights...") | |
| signal_model = SignalModel(G) | |
| signal_model.attach_signal_weights() | |
| # ββ Pollution model βββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| logger.info("[Startup] Attaching pollution weights...") | |
| pollution_model = PollutionModel(G) | |
| pollution_model.attach_pollution_weights() | |
| app.state.G = G | |
| app.state.signal_model = signal_model | |
| app.state.pollution_model = pollution_model | |
| app.state.limiter = limiter | |
| # ββ Traffic enrichment (graceful if TOMTOM key missing) βββββββββββββββββββ | |
| tomtom_key = os.environ.get("TOMTOM_API_KEY") | |
| enricher = None | |
| if tomtom_key: | |
| enricher = TrafficEnricher(G, pollution_model, tomtom_key) | |
| await enricher.enrich() | |
| asyncio.create_task(enricher.run_scheduler()) | |
| else: | |
| logger.warning("[Startup] TOMTOM_API_KEY missing β traffic enrichment disabled.") | |
| app.state.enricher = enricher | |
| startup_summary = ( | |
| "[Startup] Summary: " | |
| f"graph nodes={len(G.nodes)} " | |
| f"edges={len(G.edges)} " | |
| f"canopy_loaded={canopy_loaded} " | |
| f"canopy_segments={len(canopy_store)} " | |
| f"gee={gee_ok} " | |
| f"traffic={'enabled' if enricher else 'disabled'}" | |
| ) | |
| logger.info(startup_summary) | |
| logger.info("[Startup] Ready.") | |
| yield | |
| # ββ Shutdown ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| logger.info("[Shutdown] Cleaning up...") | |
| app.state.G = None | |
| app.state.signal_model = None | |
| app.state.pollution_model = None | |
| app.state.canopy_store = None | |
| # ββ App βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| app = FastAPI( | |
| lifespan=lifespan, | |
| title="EUDORA API", | |
| docs_url="/docs" if LOCAL_DEV else None, | |
| redoc_url="/redoc" if LOCAL_DEV else None, | |
| openapi_url="/openapi.json" if LOCAL_DEV else None, | |
| ) | |
| # Rate limit error handler | |
| app.state.limiter = limiter | |
| app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler) | |
| # Security middlewares (order matters β outermost runs first) | |
| if not LOCAL_DEV: | |
| app.add_middleware(SecurityHeadersMiddleware) | |
| app.add_middleware(RequestSizeLimitMiddleware) | |
| # CORS is permissive in local dev so local frontends/orchestrators can call main.py. | |
| app.add_middleware( | |
| CORSMiddleware, | |
| allow_origins=["*"] if LOCAL_DEV else ALLOWED_ORIGINS, | |
| allow_methods=["*"] if LOCAL_DEV else ["GET", "POST", "OPTIONS"], | |
| allow_headers=["*"], | |
| ) | |
| app.include_router(router, prefix="/api") | |
| # ββ Health endpoint βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def health_check(request: Request): | |
| """System status check β no rate limit, no auth.""" | |
| G = getattr(request.app.state, "G", None) | |
| enricher = getattr(request.app.state, "enricher", None) | |
| return { | |
| "status": "ok", | |
| "uptime_seconds": round(time.time() - _BOOT_TIME, 1) if _BOOT_TIME else 0, | |
| "graph": { | |
| "nodes": len(G.nodes) if G else 0, | |
| "edges": len(G.edges) if G else 0, | |
| }, | |
| "services": { | |
| "geocoding": bool(os.environ.get("LOCATIONIQ_TOKEN")), | |
| "tiles": bool(os.environ.get("MAPTILER_KEY")), | |
| "traffic": enricher is not None, | |
| "aqi": bool(os.environ.get("OWM_API_KEY")), | |
| }, | |
| } | |
| # ββ Geocoding helpers βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def _ola_geocode(q: str) -> list | None: | |
| """Ola Maps text search β normalized LocationIQ-style list.""" | |
| key = os.environ.get("OLA_MAPS_KEY") | |
| if not key: | |
| return None | |
| try: | |
| async with httpx.AsyncClient(timeout=6.0) as client: | |
| res = await client.get( | |
| "https://api.olamaps.io/places/v1/autocomplete", | |
| params={ | |
| "input": q, | |
| "api_key": key, | |
| "location": "22.7196,75.8577", | |
| "radius": 50000, | |
| }, | |
| headers={"X-Request-Id": "eudora-geocode"}, | |
| ) | |
| if res.status_code != 200: | |
| return None | |
| data = res.json() | |
| results = data.get("predictions") or [] | |
| normalized = [] | |
| for r in results[:6]: | |
| loc = r.get("geometry", {}).get("location", {}) | |
| lat = loc.get("lat") or loc.get("latitude") | |
| lon = loc.get("lng") or loc.get("longitude") | |
| if not lat: | |
| loc2 = r.get("place_details", {}).get("geometry", {}).get("location", {}) | |
| lat = loc2.get("lat") | |
| lon = loc2.get("lng") | |
| if not lat or not lon: | |
| continue | |
| normalized.append({ | |
| "display_name": r.get("description") or r.get("formatted_address") or r.get("name", ""), | |
| "lat": str(lat), | |
| "lon": str(lon), | |
| "place_id": r.get("place_id", ""), | |
| }) | |
| return normalized if normalized else None | |
| except Exception as e: | |
| logger.warning("[Geocode/Ola] %s", e) | |
| return None | |
| async def _locationiq_geocode(q: str) -> list | None: | |
| """LocationIQ autocomplete fallback.""" | |
| token = os.environ.get("LOCATIONIQ_TOKEN") | |
| if not token: | |
| return None | |
| try: | |
| async with httpx.AsyncClient(timeout=6.0) as client: | |
| res = await client.get( | |
| "https://api.locationiq.com/v1/autocomplete", | |
| params={"key": token, "q": q, "limit": 6, "dedupe": 1, | |
| "accept-language": "en", "countrycodes": "in", | |
| "lat": 22.7196, "lon": 75.8577}, | |
| ) | |
| return res.json() if res.status_code == 200 else None | |
| except Exception as e: | |
| logger.warning("[Geocode/LocationIQ] %s", e) | |
| return None | |
| async def _ola_reverse(lat: float, lon: float) -> dict | None: | |
| """Ola Maps reverse geocode β normalized LocationIQ-style dict.""" | |
| key = os.environ.get("OLA_MAPS_KEY") | |
| if not key: | |
| return None | |
| try: | |
| async with httpx.AsyncClient(timeout=6.0) as client: | |
| res = await client.get( | |
| "https://api.olamaps.io/places/v1/reverse-geocode", | |
| params={"latlng": f"{lat},{lon}", "api_key": key}, | |
| headers={"X-Request-Id": "eudora-reverse"}, | |
| ) | |
| if res.status_code != 200: | |
| return None | |
| data = res.json() | |
| results = data.get("results") or [] | |
| if not results: | |
| return None | |
| top = results[0] | |
| return { | |
| "display_name": top.get("formatted_address", ""), | |
| "lat": str(lat), | |
| "lon": str(lon), | |
| "address": top.get("address_components", {}), | |
| } | |
| except Exception as e: | |
| logger.warning("[Reverse/Ola] %s", e) | |
| return None | |
| async def _locationiq_reverse(lat: float, lon: float) -> dict | None: | |
| """LocationIQ reverse geocode fallback.""" | |
| token = os.environ.get("LOCATIONIQ_TOKEN") | |
| if not token: | |
| return None | |
| try: | |
| async with httpx.AsyncClient(timeout=6.0) as client: | |
| res = await client.get( | |
| "https://us1.locationiq.com/v1/reverse", | |
| params={"key": token, "lat": lat, "lon": lon, "format": "json"}, | |
| ) | |
| return res.json() if res.status_code == 200 else None | |
| except Exception as e: | |
| logger.warning("[Reverse/LocationIQ] %s", e) | |
| return None | |
| # ββ Proxy endpoints βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def geocode_proxy(request: Request, q: str = Query(..., min_length=2, max_length=200)): | |
| result = await _ola_geocode(q) | |
| if result is None: | |
| logger.info(f"[Geocode] Ola Maps failed or not configured for '{q}' β falling back to LocationIQ") | |
| result = await _locationiq_geocode(q) | |
| if result is not None: | |
| logger.info(f"[Geocode] Successfully used LocationIQ for '{q}'") | |
| else: | |
| logger.info(f"[Geocode] Successfully used Ola Maps for '{q}'") | |
| if result is None: | |
| return JSONResponse(status_code=503, content={"error": "Geocoding unavailable."}) | |
| return result | |
| async def reverse_proxy( | |
| request: Request, | |
| lat: float = Query(..., ge=-90.0, le=90.0), | |
| lon: float = Query(..., ge=-180.0, le=180.0), | |
| ): | |
| result = await _ola_reverse(lat, lon) | |
| if result is None: | |
| logger.info(f"[Reverse] Ola Maps failed or not configured for {lat},{lon} β falling back to LocationIQ") | |
| result = await _locationiq_reverse(lat, lon) | |
| if result is not None: | |
| logger.info(f"[Reverse] Successfully used LocationIQ for {lat},{lon}") | |
| else: | |
| logger.info(f"[Reverse] Successfully used Ola Maps for {lat},{lon}") | |
| if result is None: | |
| return JSONResponse(status_code=503, content={"error": "Reverse geocoding unavailable."}) | |
| return result | |
| # ββ Tile proxy β MapTiler βββββββββββββββββββββββββββββββββββββββββββββββββββββ | |
| async def tile_proxy( | |
| request: Request, | |
| style: str, | |
| z: int = FastAPIPath(..., ge=0, le=22), | |
| x: int = FastAPIPath(..., ge=0), | |
| y: int = FastAPIPath(..., ge=0), | |
| ): | |
| """ | |
| Proxies map tile requests to MapTiler. | |
| The API key never reaches the frontend. | |
| """ | |
| allowed_styles = {"dataviz-dark", "dataviz"} | |
| if style not in allowed_styles: | |
| return JSONResponse(status_code=400, content={"error": "Invalid style."}) | |
| # Validate x/y within tile grid bounds for zoom level | |
| max_tile = (1 << z) - 1 # 2^z - 1 | |
| if x > max_tile or y > max_tile: | |
| return JSONResponse(status_code=400, content={"error": "Tile coordinates out of range."}) | |
| maptiler_key = os.environ.get("MAPTILER_KEY") | |
| if not maptiler_key: | |
| return JSONResponse(status_code=503, content={"error": "Tiles not configured."}) | |
| url = f"https://api.maptiler.com/maps/{style}/{z}/{x}/{y}.png?key={maptiler_key}" | |
| try: | |
| async with httpx.AsyncClient(timeout=8.0) as client: | |
| res = await client.get(url) | |
| return Response( | |
| content=res.content, | |
| media_type="image/png", | |
| headers={"Cache-Control": "public, max-age=86400"}, | |
| ) | |
| except Exception as e: | |
| logger.error(f"[Tile proxy] Exception: {str(e)}", exc_info=True) | |
| return JSONResponse(status_code=500, content={"error": f"Tile fetch failed: {str(e)}"}) | |