Upload 2 files

app.py

@@ -0,0 +1,279 @@
+# VARK Simple Parking Grid Demo
+# Paste this file as app.py in a Hugging Face Space (Gradio SDK)
+
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Tuple
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import matplotlib.patches as patches
+
+# -----------------------------
+# Config
+# -----------------------------
+ROWS = 4
+COLS = 5
+PLATFORM_COUNT = 16
+DROP_POINT = (0, 0)  # row, col
+STEP_DELAY = 0.08
+
+# -----------------------------
+# Data models
+# -----------------------------
+@dataclass
+class Platform:
+    pid: int
+    r: int
+    c: int
+    car_id: Optional[int] = None
+    home: Tuple[int, int] = (0, 0)
+
+@dataclass
+class State:
+    platforms: Dict[int, Platform] = field(default_factory=dict)
+    occupancy: Dict[Tuple[int, int], Optional[int]] = field(default_factory=dict)
+    cars: Dict[int, int] = field(default_factory=dict)  # car_id -> platform_id
+    log: List[str] = field(default_factory=list)
+
+# -----------------------------
+# Helpers
+# -----------------------------
+def in_bounds(r, c):
+    return 0 <= r < ROWS and 0 <= c < COLS
+
+def manhattan(a, b):
+    return abs(a[0] - b[0]) + abs(a[1] - b[1])
+
+# -----------------------------
+# Init
+# -----------------------------
+def init_state():
+    st = State()
+
+    # four empty cells
+    empty = {(0, 4), (1, 2), (3, 0), (3, 4)}
+
+    for r in range(ROWS):
+        for c in range(COLS):
+            st.occupancy[(r, c)] = None
+
+    pid = 1
+    for r in range(ROWS):
+        for c in range(COLS):
+            if (r, c) in empty:
+                continue
+            if pid > PLATFORM_COUNT:
+                continue
+            p = Platform(pid=pid, r=r, c=c, home=(r, c))
+            st.platforms[pid] = p
+            st.occupancy[(r, c)] = pid
+            pid += 1
+
+    st.log.append("System initialised: 4x5 grid, 16 platforms, 4 empty cells")
+    st.log.append(f"Drop / Pick point at {DROP_POINT}")
+    return st
+
+# -----------------------------
+# Rendering
+# -----------------------------
+def render(st):
+    fig, ax = plt.subplots(figsize=(7, 5))
+
+    for r in range(ROWS):
+        for c in range(COLS):
+            ax.add_patch(patches.Rectangle((c, ROWS - 1 - r), 1, 1, fill=False))
+
+    dr, dc = DROP_POINT
+    ax.add_patch(patches.Rectangle((dc, ROWS - 1 - dr), 1, 1, fill=False, linewidth=3))
+    ax.text(dc + 0.5, ROWS - dr - 0.15, "DROP / PICK", ha="center", va="top", fontsize=9)
+
+    for p in st.platforms.values():
+        label = f"P{p.pid}"
+        if p.car_id is not None:
+            label += f"\nCar {p.car_id}"
+        ax.text(p.c + 0.5, ROWS - 1 - p.r + 0.5, label, ha="center", va="center")
+
+    ax.set_xlim(0, COLS)
+    ax.set_ylim(0, ROWS)
+    ax.set_aspect("equal")
+    ax.axis("off")
+    return fig
+
+# -----------------------------
+# Movement logic (4-direction only)
+# -----------------------------
+def step_towards(src, dst):
+    r, c = src
+    tr, tc = dst
+    if r < tr:
+        return r + 1, c
+    if r > tr:
+        return r - 1, c
+    if c < tc:
+        return r, c + 1
+    if c > tc:
+        return r, c - 1
+    return r, c
+
+
+def move_one(st, pid, target):
+    p = st.platforms[pid]
+    cur = (p.r, p.c)
+    if not in_bounds(*target):
+        return
+
+    occ = st.occupancy[target]
+    if occ is None:
+        st.occupancy[cur] = None
+        p.r, p.c = target
+        st.occupancy[target] = pid
+    else:
+        other = st.platforms[occ]
+        p.r, other.r = other.r, p.r
+        p.c, other.c = other.c, p.c
+        st.occupancy[(p.r, p.c)] = pid
+        st.occupancy[(other.r, other.c)] = occ
+
+
+def animate_move(st, pid, dst):
+    p = st.platforms[pid]
+    while (p.r, p.c) != dst:
+        nxt = step_towards((p.r, p.c), dst)
+        move_one(st, pid, nxt)
+        yield st
+        time.sleep(STEP_DELAY)
+
+# -----------------------------
+# Business logic
+# -----------------------------
+def free_platform(st):
+    free = [p for p in st.platforms.values() if p.car_id is None]
+    if not free:
+        return None
+    free.sort(key=lambda p: manhattan((p.r, p.c), DROP_POINT))
+    return free[0].pid
+
+
+def drop_off(st, car_id):
+    if car_id in st.cars:
+        st.log.append(f"Car {car_id} already parked")
+        yield st
+        return
+
+    if len(st.cars) >= PLATFORM_COUNT:
+        st.log.append("Garage full (16 cars)")
+        yield st
+        return
+
+    pid = free_platform(st)
+    if pid is None:
+        st.log.append("No empty platform available")
+        yield st
+        return
+
+    st.log.append(f"Dispatch P{pid} to DROP for Car {car_id}")
+    for _ in animate_move(st, pid, DROP_POINT):
+        yield st
+
+    st.platforms[pid].car_id = car_id
+    st.cars[car_id] = pid
+    st.log.append(f"Car {car_id} loaded onto P{pid}")
+
+    home = st.platforms[pid].home
+    for _ in animate_move(st, pid, home):
+        yield st
+
+    st.log.append(f"Car {car_id} stored")
+    yield st
+
+
+def pick_up(st, car_id):
+    if car_id not in st.cars:
+        st.log.append(f"Car {car_id} not found")
+        yield st
+        return
+
+    pid = st.cars[car_id]
+    st.log.append(f"Dispatch P{pid} for PICK UP of Car {car_id}")
+
+    for _ in animate_move(st, pid, DROP_POINT):
+        yield st
+
+    st.platforms[pid].car_id = None
+    del st.cars[car_id]
+    st.log.append(f"Car {car_id} unloaded")
+
+    home = st.platforms[pid].home
+    for _ in animate_move(st, pid, home):
+        yield st
+
+    st.log.append(f"P{pid} returned to grid")
+    yield st
+
+# -----------------------------
+# UI handlers
+# -----------------------------
+def reset_ui():
+    st = init_state()
+    return st, render(st), "\n".join(st.log), f"{len(st.cars)} / 16"
+
+
+def ui_drop(st, car):
+    try:
+        cid = int(car)
+    except:
+        st.log.append("Invalid car ID")
+        yield st, render(st), "\n".join(st.log), f"{len(st.cars)} / 16"
+        return
+
+    for s in drop_off(st, cid):
+        yield s, render(s), "\n".join(s.log[-12:]), f"{len(s.cars)} / 16"
+
+
+def ui_pick(st, car):
+    try:
+        cid = int(car)
+    except:
+        st.log.append("Invalid car ID")
+        yield st, render(st), "\n".join(st.log), f"{len(st.cars)} / 16"
+        return
+
+    for s in pick_up(st, cid):
+        yield s, render(s), "\n".join(s.log[-12:]), f"{len(s.cars)} / 16"
+
+# -----------------------------
+# Gradio App
+# -----------------------------
+with gr.Blocks(title="VARK Parking Grid Demo") as demo:
+    state = gr.State(init_state())
+
+    gr.Markdown("""
+4x5 grid parking system demo
+
+- 16 movable platforms
+- 4 empty cells
+- Platforms move only up / down / left / right
+- DROP OFF brings an empty platform to the drop point
+- PICK UP retrieves a car by ID
+    """)
+
+    car_id = gr.Textbox(label="Car ID", value="101")
+    capacity = gr.Textbox(label="Capacity", value="0 / 16", interactive=False)
+
+    with gr.Row():
+        drop_btn = gr.Button("DROP OFF")
+        pick_btn = gr.Button("PICK UP")
+        reset_btn = gr.Button("RESET")
+
+    plot = gr.Plot()
+    log = gr.Textbox(lines=14, interactive=False)
+
+    plot.value = render(state.value)
+    log.value = "\n".join(state.value.log)
+
+    reset_btn.click(reset_ui, outputs=[state, plot, log, capacity])
+    drop_btn.click(ui_drop, inputs=[state, car_id], outputs=[state, plot, log, capacity])
+    pick_btn.click(ui_pick, inputs=[state, car_id], outputs=[state, plot, log, capacity])
+
+demo.queue().launch()

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.0.0
+matplotlib