Deploy App to HF Spaces

Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+# Create the user according to Hugging Face specs
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1
+
+WORKDIR $HOME/app
+
+# Install poetry
+RUN pip install --no-cache-dir poetry
+
+# Copy dependency files
+COPY --chown=user pyproject.toml poetry.lock* ./
+
+# Install dependencies without virtualenvs setup for container
+RUN poetry config virtualenvs.create false && \
+    poetry install --no-interaction --no-ansi --no-root
+
+# Copy rest of the application
+COPY --chown=user src/ ./src/
+
+EXPOSE 7860
+
+# Command to run the application space
+CMD ["poetry", "run", "uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,10 @@
+---
+title: TrafficSimApp
+emoji: 🚗
+colorFrom: gray
+colorTo: red
+sdk: docker
+pinned: false
+license: apache-2.0
+short_description: app for traffic simulation project
+---

pyproject.toml

@@ -0,0 +1,19 @@
+[tool.poetry]
+name = "sim-backend"
+version = "0.1.0"
+description = "Simulation backend for vehicular traffic offloading"
+authors = ["Author <author@example.com>"]
+readme = "README.md"
+packages = [{include = "app", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+fastapi = "^0.103.0"
+uvicorn = "^0.23.0"
+pydantic = "^2.3.0"
+osmnx = "^1.6.0"
+networkx = "^3.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

src/app/api/routes.py

@@ -0,0 +1,71 @@
+from fastapi import APIRouter
+from app.core.state import sim_state
+from app.models.schemas import ConfigState, ResetConfig
+from app.simulation.engine import run_step, init_sim_entities
+
+router = APIRouter()
+
+@router.post("/start")
+def start_sim():
+    sim_state.running = True
+    return {"status": "started"}
+
+@router.post("/pause")
+def pause_sim():
+    sim_state.running = False
+    return {"status": "paused"}
+
+@router.post("/step")
+def step_sim():
+    run_step()
+    return {"status": "stepped"}
+
+@router.post("/algorithm")
+def set_algorithm(config: ConfigState):
+    sim_state.algorithm = config.algorithm
+    return {"status": "success", "algorithm": sim_state.algorithm}
+
+@router.post("/reset")
+def reset_sim(config: ResetConfig):
+    sim_state.num_hubs = config.num_hubs
+    sim_state.num_vehicles = config.num_vehicles
+    sim_state.event_rate = config.event_rate
+    init_sim_entities()
+    return {"status": "reset_successful"}
+
+@router.get("/roads")
+def get_roads():
+    return sim_state.roads
+
+@router.get("/state")
+def get_state():
+    return {
+        "running": sim_state.running,
+        "step": sim_state.step,
+        "algorithm": sim_state.algorithm,
+        "total_generated_mb": sim_state.total_generated_mb,
+        "total_offloaded_mb": sim_state.total_offloaded_mb,
+        "vehicles": sim_state.vehicles,
+        "hubs": sim_state.hubs,
+        "recent_events": sim_state.recent_events
+    }
+
+@router.get("/report")
+def export_report():
+    avg_latency = 0
+    if sim_state.priority_events_completed > 0:
+        avg_latency = sim_state.priority_latency_sum / sim_state.priority_events_completed
+        
+    hub_utilization = {f"Hub_{h['id']}": round(h["total_offloaded_mb"], 2) for h in sim_state.hubs}
+    
+    return {
+        "algorithm": sim_state.algorithm,
+        "total_steps": sim_state.step,
+        "completed_events": sim_state.priority_events_completed,
+        "average_priority_latency_steps": round(avg_latency, 2),
+        "total_buffer_overflows": sim_state.total_buffer_overflows,
+        "hub_utilization_mb": hub_utilization,
+        "total_generated_mb": round(sim_state.total_generated_mb, 2),
+        "total_offloaded_mb": round(sim_state.total_offloaded_mb, 2),
+        "overall_efficiency": f"{round((sim_state.total_offloaded_mb / max(1, sim_state.total_generated_mb)) * 100, 2)}%"
+    }

src/app/core/config.py

@@ -0,0 +1,8 @@
+# Configuration
+LOCATION = "Faizabad Interchange, Islamabad, Pakistan"
+WIFI_RANGE_METERS = 100
+WIFI_RATE_MB_S = 1.5      # MB per 0.1s step (effectively 15 MB/s)
+DATA_GEN_RATE_MB_STEP = 0.1 # effectively 1 MB/s
+NUM_VEHICLES = 50
+NUM_HUBS = 15
+MAX_BUFFER_MB = 50.0

src/app/core/state.py

@@ -0,0 +1,23 @@
+from app.core.config import NUM_HUBS, NUM_VEHICLES
+
+class SimulationState:
+    def __init__(self):
+        self.running = False
+        self.step = 0
+        self.algorithm = "greedy" # 'greedy' or 'predictive'
+        self.total_generated_mb = 0.0
+        self.total_offloaded_mb = 0.0
+        self.total_buffer_overflows = 0
+        self.priority_latency_sum = 0
+        self.priority_events_completed = 0
+        self.num_hubs = NUM_HUBS
+        self.num_vehicles = NUM_VEHICLES
+        self.event_rate = 0.0005
+        self.graph = None
+        self.hubs = []
+        self.vehicles = []
+        self.roads = []
+        self.recent_events = []
+
+# Single global instance
+sim_state = SimulationState()

src/app/main.py

@@ -0,0 +1,51 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+import asyncio
+import osmnx as ox
+
+from app.api.routes import router as api_router
+from app.core.state import sim_state
+from app.core.config import LOCATION
+from app.simulation.engine import init_sim_entities, simulation_loop
+
+app = FastAPI(title="Simulation Backend")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(api_router)
+
+@app.on_event("startup")
+async def startup_event():
+    print(f"Loading graph for {LOCATION}...")
+    try:
+        sim_state.graph = ox.graph_from_place(LOCATION, network_type="drive")
+    except Exception as e:
+        print("Failed to download exact place, using bounding box or default fallback...", e)
+        sim_state.graph = ox.graph_from_point((33.6515, 73.0801), dist=2500, network_type="drive")
+    
+    # Extract roads for frontend rendering
+    roads = []
+    for u, v, data in sim_state.graph.edges(data=True):
+        if 'geometry' in data:
+            coords = list(data['geometry'].coords)
+            roads.append([[pt[1], pt[0]] for pt in coords])
+        else:
+            u_node = sim_state.graph.nodes[u]
+            v_node = sim_state.graph.nodes[v]
+            roads.append([[u_node['y'], u_node['x']], [v_node['y'], v_node['x']]])
+    sim_state.roads = roads
+    
+    init_sim_entities()
+
+    print("Simulation initialized.")
+    asyncio.create_task(simulation_loop())
+
+if __name__ == "__main__":
+    import uvicorn
+    # Make sure to run the file inside `src/` to correctly access `app.main:app` module.
+    uvicorn.run("app.main:app", host="0.0.0.0", port=8000, reload=True)

src/app/models/schemas.py

@@ -0,0 +1,9 @@
+from pydantic import BaseModel
+
+class ConfigState(BaseModel):
+    algorithm: str
+
+class ResetConfig(BaseModel):
+    num_hubs: int
+    num_vehicles: int
+    event_rate: float

src/app/rl/__init__.py

@@ -0,0 +1 @@
+# This file initializes the RL module

src/app/rl/train.py

@@ -0,0 +1,28 @@
+import asyncio
+import logging
+import os
+
+logger = logging.getLogger(__name__)
+
+async def start_training_loop():
+    """
+    Minimal dummy RL training loop that runs asynchronously.
+    """
+    logger.info("Initializing RL Training environment...")
+    
+    # Ensure models directory exists
+    os.makedirs("models", exist_ok=True)
+    
+    epoch = 0
+    while True:
+        logger.info(f"Running training epoch {epoch}...")
+        
+        # Simulate training work
+        await asyncio.sleep(10)
+        
+        # Save a dummy model
+        with open(f"models/dummy_model_v{epoch}.pkl", "w") as f:
+            f.write(f"Model parameters for epoch {epoch}")
+        
+        logger.info(f"Epoch {epoch} complete and model saved.")
+        epoch += 1

src/app/simulation/engine.py

@@ -0,0 +1,221 @@
+import asyncio
+import random
+import math
+import networkx as nx
+
+from app.core.state import sim_state
+from app.core.config import DATA_GEN_RATE_MB_STEP, MAX_BUFFER_MB, WIFI_RANGE_METERS
+from app.simulation.utils import euclidean_dist
+
+def init_sim_entities():
+    nodes = list(sim_state.graph.nodes(data=True))
+    sim_state.hubs = []
+    sim_state.vehicles = []
+    sim_state.step = 0
+    sim_state.total_generated_mb = 0.0
+    sim_state.total_offloaded_mb = 0.0
+    sim_state.total_buffer_overflows = 0
+    sim_state.priority_latency_sum = 0
+    sim_state.priority_events_completed = 0
+    sim_state.recent_events = []
+
+    center_lat = 33.6515
+    center_lon = 73.0801
+    top_right_nodes = [n for n in nodes if n[1]["y"] > center_lat + 0.005 and n[1]["x"] > center_lon + 0.005]
+    if len(top_right_nodes) >= 2 and sim_state.num_hubs >= 2:
+        tr_hubs = random.sample(top_right_nodes, 2)
+        other_nodes = [n for n in nodes if n not in tr_hubs]
+        hub_nodes = tr_hubs + random.sample(other_nodes, sim_state.num_hubs - 2)
+    else:
+        hub_nodes = random.sample(nodes, sim_state.num_hubs)
+
+    for hid, node in enumerate(hub_nodes):
+        sim_state.hubs.append({
+            "id": hid,
+            "lat": node[1]["y"],
+            "lon": node[1]["x"],
+            "range": WIFI_RANGE_METERS,
+            "rate": random.choice([1.0, 2.5, 5.0]),
+            "active": False,
+            "online": True,
+            "total_offloaded_mb": 0.0
+        })
+    
+    node_ids = list(sim_state.graph.nodes())
+    for vid in range(sim_state.num_vehicles):
+        n1 = random.choice(node_ids)
+        n2 = random.choice(node_ids)
+        try:
+            path = nx.shortest_path(sim_state.graph, n1, n2, weight='length')
+        except:
+            path = [n1]
+
+        start_data = sim_state.graph.nodes[n1]
+        target_lat = start_data["y"]
+        target_lon = start_data["x"]
+        
+        if len(path) > 1:
+            next_node = path[1]
+            target_lat = sim_state.graph.nodes[next_node]["y"]
+            target_lon = sim_state.graph.nodes[next_node]["x"]
+
+        base_spd = random.uniform(0.00004, 0.00008)
+        sim_state.vehicles.append({
+            "id": vid,
+            "lat": start_data["y"],
+            "lon": start_data["x"],
+            "buffer_mb": 0.0,
+            "routine_mb": 0.0,
+            "priority_mb": 0.0,
+            "panic": False,
+            "target_lat": target_lat,
+            "target_lon": target_lon,
+            "path": path,
+            "path_idx": 1 if len(path) > 1 else 0,
+            "base_speed": base_spd,
+            "speed": base_spd,
+            "events": []
+        })
+
+async def simulation_loop():
+    while True:
+        if sim_state.running:
+            run_step()
+        await asyncio.sleep(0.05) 
+
+def run_step():
+    sim_state.step += 1
+    
+    for hub in sim_state.hubs:
+        hub["active"] = False
+        if random.random() < 0.001:
+            hub["online"] = not hub["online"]
+
+    node_ids = list(sim_state.graph.nodes())
+    edge_traffic = {}
+    for v in sim_state.vehicles:
+        if v["path"] and v["path_idx"] < len(v["path"]):
+            prev = v["path"][v["path_idx"]-1] if v["path_idx"] > 0 else v["path"][0]
+            curr = v["path"][v["path_idx"]]
+            edge_traffic[(prev, curr)] = edge_traffic.get((prev, curr), 0) + 1
+
+    EVENT_TYPES = ["Pothole", "Minor Crash", "Debris", "Speed Trap", "Traffic Jam"]
+
+    for v in sim_state.vehicles:
+        v["routine_mb"] += DATA_GEN_RATE_MB_STEP
+        sim_state.total_generated_mb += DATA_GEN_RATE_MB_STEP
+        
+        if v["path"] and v["path_idx"] < len(v["path"]):
+            prev = v["path"][v["path_idx"]-1] if v["path_idx"] > 0 else v["path"][0]
+            curr = v["path"][v["path_idx"]]
+            vehicles_on_edge = edge_traffic.get((prev, curr), 1)
+            v["speed"] = v["base_speed"] / max(1, vehicles_on_edge)
+
+        if random.random() < sim_state.event_rate:
+            evt_type = random.choice(EVENT_TYPES)
+            evt_size = random.uniform(5.0, 10.0)
+            v["events"].append({"type": evt_type, "size": evt_size, "timestamp": sim_state.step})
+            v["priority_mb"] += evt_size
+            sim_state.total_generated_mb += evt_size
+
+        total_buf = v["routine_mb"] + v["priority_mb"]
+        if total_buf > MAX_BUFFER_MB:
+            overflow_amt = total_buf - MAX_BUFFER_MB
+            dropped_mb = min(overflow_amt, v["routine_mb"])
+            if dropped_mb > 0:
+                v["routine_mb"] -= dropped_mb
+                sim_state.total_buffer_overflows += 1
+        
+        v["buffer_mb"] = v["routine_mb"] + v["priority_mb"]
+
+        dx = v["target_lon"] - v["lon"]
+        dy = v["target_lat"] - v["lat"]
+        dist = math.sqrt(dx*dx + dy*dy)
+        if dist < v["speed"]:
+            v["lon"] = v["target_lon"]
+            v["lat"] = v["target_lat"]
+            v["path_idx"] += 1
+            if v["path_idx"] < len(v["path"]):
+                next_node = v["path"][v["path_idx"]]
+                v["target_lat"] = sim_state.graph.nodes[next_node]["y"]
+                v["target_lon"] = sim_state.graph.nodes[next_node]["x"]
+            else:
+                start_node = v["path"][-1] if v["path"] else random.choice(node_ids)
+                end_node = random.choice(node_ids)
+                try:
+                    new_path = nx.shortest_path(sim_state.graph, start_node, end_node, weight='length')
+                except:
+                    new_path = [start_node]
+                
+                v["path"] = new_path
+                v["path_idx"] = 1
+                if len(new_path) > 1:
+                    next_node = new_path[1]
+                    v["target_lat"] = sim_state.graph.nodes[next_node]["y"]
+                    v["target_lon"] = sim_state.graph.nodes[next_node]["x"]
+                else:
+                    v["target_lat"] = v["lat"]
+                    v["target_lon"] = v["lon"]
+        else:
+            v["lon"] += (dx/dist) * v["speed"]
+            v["lat"] += (dy/dist) * v["speed"]
+        
+        closest_hub = None
+        min_dist = float('inf')
+        for hub in sim_state.hubs:
+            d = euclidean_dist(v["lat"], v["lon"], hub["lat"], hub["lon"])
+            if d < min_dist:
+                min_dist = d
+                closest_hub = hub
+                
+        if closest_hub and min_dist <= closest_hub["range"]:
+            if not closest_hub["online"]:
+                v["panic"] = True
+            else:
+                skip_offload = False
+                
+                if sim_state.algorithm == "predictive" and not v.get("panic", False) and (v["routine_mb"] + v["priority_mb"]) < MAX_BUFFER_MB * 0.8:
+                    future_nodes = v["path"][v["path_idx"]:v["path_idx"]+10]
+                    for f_node in future_nodes:
+                        ny = sim_state.graph.nodes[f_node]["y"]
+                        nx_coord = sim_state.graph.nodes[f_node]["x"]
+                        for h in sim_state.hubs:
+                            if h["online"] and h["rate"] > closest_hub["rate"] and euclidean_dist(ny, nx_coord, h["lat"], h["lon"]) <= h["range"]:
+                                skip_offload = True
+                                break
+                        if skip_offload:
+                            break
+                
+                if not skip_offload:
+                    amt_to_offload = closest_hub["rate"]
+                    
+                    while v["events"] and amt_to_offload > 0:
+                        evt = v["events"][0]
+                        if evt["size"] <= amt_to_offload:
+                            amt_to_offload -= evt["size"]
+                            v["priority_mb"] -= evt["size"]
+                            sim_state.total_offloaded_mb += evt["size"]
+                            closest_hub["total_offloaded_mb"] += evt["size"]
+                            latency = sim_state.step - evt["timestamp"]
+                            sim_state.priority_latency_sum += latency
+                            sim_state.priority_events_completed += 1
+                            v["events"].pop(0)
+                            sim_state.recent_events.insert(0, f"[{sim_state.step}] Veh {v['id']} offloaded '{evt['type']}' to Hub {closest_hub['id']} (Lat: {latency}s)")
+                        else:
+                            evt["size"] -= amt_to_offload
+                            v["priority_mb"] -= amt_to_offload
+                            sim_state.total_offloaded_mb += amt_to_offload
+                            closest_hub["total_offloaded_mb"] += amt_to_offload
+                            amt_to_offload = 0
+                            
+                    if amt_to_offload > 0 and v["routine_mb"] > 0:
+                        off_routine = min(v["routine_mb"], amt_to_offload)
+                        v["routine_mb"] -= off_routine
+                        sim_state.total_offloaded_mb += off_routine
+                        closest_hub["total_offloaded_mb"] += off_routine
+                        
+                    closest_hub["active"] = True
+                    v["panic"] = False 
+            
+            v["buffer_mb"] = v["routine_mb"] + v["priority_mb"]
+            sim_state.recent_events = sim_state.recent_events[:30]

src/app/simulation/utils.py

@@ -0,0 +1,9 @@
+import math
+
+def euclidean_dist(lat1, lon1, lat2, lon2):
+    # Rough approximation for small distances, returning meters
+    # 1 deg lat = 111,320m
+    lat_mid = (lat1 + lat2) / 2.0
+    dx = (lon2 - lon1) * 111320.0 * math.cos(math.radians(lat_mid))
+    dy = (lat2 - lat1) * 111320.0
+    return math.sqrt(dx*dx + dy*dy)

src/app/train_main.py

@@ -0,0 +1,27 @@
+import asyncio
+import logging
+from fastapi import FastAPI
+from app.rl.train import start_training_loop
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(title="RL Training Headless Space")
+
+@app.on_event("startup")
+async def startup_event():
+    logger.info("Starting headless RL training server...")
+    # Launch the RL training loop as a background task
+    asyncio.create_task(start_training_loop())
+
+@app.get("/health")
+def health_check():
+    """
+    Minimal health check endpoint required by Hugging Face Spaces on port 7860.
+    """
+    return {"status": "ok", "message": "Training is running"}
+
+if __name__ == "__main__":
+    import uvicorn
+    # Hugging Face spaces expect port 7860
+    uvicorn.run("app.train_main:app", host="0.0.0.0", port=7860)