Upload 7 files

.gitignore

@@ -1,2 +1,5 @@
-API
-API.py
+.venv/
+__pycache__/
+.idea/
+*.pyc
+.env

Dockerfile

@@ -1,16 +1,32 @@
-# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-# you will also find guides on how best to write your Dockerfile
+FROM python:3.9-slim
 
-FROM python:3.9
+# Prevent Python buffering
+ENV PYTHONUNBUFFERED=1
 
+# Create non-root user
 RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
 
+# Set working directory
 WORKDIR /app
 
-COPY --chown=user ../requirements.txt requirements.txt
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
+# Copy requirements first for better Docker caching
+COPY requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY . .
+
+# Change ownership
+RUN chown -R user:user /app
+
+# Switch to non-root user
+USER user
+
+# Expose Hugging Face Spaces port
+EXPOSE 7860
 
-COPY --chown=user .. /app
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+# Run application
+CMD ["python", "app.py"]

app.py

@@ -2,15 +2,910 @@
 # -*- coding: utf-8 -*-
 """
 @Author  : Mihir Mithani
-@Date    : 05-05-2026 , 12:16
-@File    : app.py.py
-@Desc    : 
+@Date    : 08-05-2026 , 10:57
+@File    : chip_routingv3.py
+@Desc    :
 """
-from fastapi import FastAPI
+"""
+chip_routing_cuopt.py
+─────────────────────────────────────────────────────────────────────────────
+Interactive chip routing optimizer with REAL PCB-style routing.
+
+Routing engine
+──────────────
+  • Octilinear A* pathfinding — only 90° and 45° turns, like real EDA tools
+  • Sequential net routing with incremental blocking so wires NEVER share
+    grid edges or cross each other
+  • Via dots drawn at every bend
+  • Solid lines for orthogonal (90°) hops, dashed for diagonal (45°) hops
+  • cuOpt VRP used to find the optimal ORDER to route nets
+    (minimises total wire length globally)
+
+Usage
+─────
+  pip install requests
+  python chip_routing_cuopt.py
+
+Set NVIDIA_API_KEY env-var or edit the constant below.
+"""
+
+import heapq
+import time
+import tkinter as tk
+from tkinter import messagebox, simpledialog
+
+import requests
+
+import API
+
+# ─── API ──────────────────────────────────────────────────────────────────────
+NVIDIA_API_KEY = API.API()
+INVOKE_URL = "https://optimize.api.nvidia.com/v1/nvidia/cuopt"
+FETCH_URL_FMT = "https://optimize.api.nvidia.com/v1/status/{}"
+POLL_INTERVAL = 1.2
+MAX_WAIT = 120
+
+HEADERS = {
+    "Authorization": f"Bearer {NVIDIA_API_KEY}",
+    "Accept": "application/json",
+    "Content-Type": "application/json",
+}
+
+# ─── Theme ────────────────────────────────────────────────────────────────────
+T = {
+    "bg": "#0a0c14",
+    "panel": "#10131f",
+    "panel2": "#14192a",
+    "border": "#1e2440",
+    "accent": "#4f6ef7",
+    "accent2": "#c084fc",
+    "text": "#dde1f5",
+    "muted": "#4a5275",
+    "cell_empty": "#0e1120",
+    "cell_comp": "#0e2040",
+    "cell_depot": "#1a0e40",
+    "cell_sel": "#0e3020",
+    "cell_hover": "#161c38",
+    "ok": "#22d3a0",
+    "warn": "#facc15",
+    "danger": "#f87171",
+}
+
+NET_COLORS = [
+    "#4f6ef7", "#22d3a0", "#facc15", "#f87171", "#c084fc",
+    "#fb923c", "#38bdf8", "#f472b6", "#a3e635", "#e879f9",
+]
+
+CELL_W = 72
+CELL_H = 50
+GPAD = 14
+
+# ─── Octilinear A* ────────────────────────────────────────────────────────────
+# 8 directions: N, S, E, W, NE, NW, SE, SW
+DIRS = [
+    (0, 1, 1.0),
+    (0, -1, 1.0),
+    (1, 0, 1.0),
+    (-1, 0, 1.0),
+    (1, 1, 1.414),
+    (1, -1, 1.414),
+    (-1, 1, 1.414),
+    (-1, -1, 1.414),
+]
+
+
+def astar(src_rc, dst_rc, rows, cols, blocked: set, comp_nodes: set):
+    """
+    Octilinear A* path from src_rc to dst_rc.
+    blocked    : cells occupied by previously routed wires (interior points)
+    comp_nodes : cells containing a component — impassable unless src/dst
+    Returns list of (r,c) from src to dst inclusive, or None.
+    """
+    passable = {src_rc, dst_rc}
+    walls = (blocked | comp_nodes) - passable
+
+    sr, sc = src_rc
+    dr, dc = dst_rc
+
+    def h(r, c):
+        return max(abs(r - dr), abs(c - dc))  # Chebyshev — admissible
+
+    # heap: (f, g, r, c, parent)
+    heap = [(h(sr, sc), 0.0, sr, sc, None)]
+    came = {}
+    gscore = {(sr, sc): 0.0}
+
+    while heap:
+        f, g, r, c, parent = heapq.heappop(heap)
+        node = (r, c)
+        if node in came:
+            continue
+        came[node] = parent
+
+        if node == (dr, dc):
+            path = []
+            cur = node
+            while cur is not None:
+                path.append(cur)
+                cur = came[cur]
+            path.reverse()
+            return path
+
+        for ddr, ddc, cost in DIRS:
+            nr, nc = r + ddr, c + ddc
+            if not (0 <= nr < rows and 0 <= nc < cols):
+                continue
+            if (nr, nc) in walls:
+                continue
+            # diagonal squeeze-through check
+            if abs(ddr) == 1 and abs(ddc) == 1:
+                if (r + ddr, c) in walls and (r, c + ddc) in walls:
+                    continue
+            ng = g + cost
+            if ng < gscore.get((nr, nc), 1e18):
+                gscore[(nr, nc)] = ng
+                heapq.heappush(heap, (ng + h(nr, nc), ng, nr, nc, node))
+
+    return None
+
+
+def route_all_nets(pairs, rows, cols, components, order=None):
+    """
+    Route nets in the given order using sequential A* with incremental blocking.
+    Returns dict: net_name -> list of (r,c)
+    """
+
+    def n2rc(n):
+        return (n // cols, n % cols)
+
+    comp_nodes = {n2rc(n) for n in components}
+    blocked = set()  # interior cells already used by prior nets
+    results = {}
+
+    if order is None:
+        order = list(range(len(pairs)))
+
+    for idx in order:
+        p = pairs[idx]
+        src = n2rc(p["src"])
+        dst = n2rc(p["sink"])
+        path = astar(src, dst, rows, cols, blocked, comp_nodes)
+
+        if path is None:
+            # rip-up fallback: ignore wire blocking, respect only components
+            path = astar(src, dst, rows, cols, set(), comp_nodes)
+
+        results[p["name"]] = path or []
+
+        if path:
+            # block interior cells (not endpoints) for subsequent nets
+            for cell in path[1:-1]:
+                blocked.add(cell)
+
+    return results
+
+
+# ─── cuOpt helpers ────────────────────────────────────────────────────────────
+
+def _cost_matrix(rows, cols, layer_id):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        ra, ca = divmod(a, cols)
+        row = []
+        for b in range(n):
+            if a == b:
+                row.append(0)
+                continue
+            rb, cb = divmod(b, cols)
+            hd = abs(ca - cb)
+            vd = abs(ra - rb)
+            pen = vd if layer_id == 1 else hd
+            row.append(max(1, hd + vd + pen))
+        mat.append(row)
+    return mat
+
+
+def _delay_matrix(rows, cols):
+    n = rows * cols
+    mat = []
+    for a in range(n):
+        ra, ca = divmod(a, cols)
+        row = []
+        for b in range(n):
+            if a == b:
+                row.append(0)
+            else:
+                rb, cb = divmod(b, cols)
+                row.append(max(1, abs(ra - rb) + abs(ca - cb)))
+        mat.append(row)
+    return mat
+
+
+def cuopt_net_order(rows, cols, pairs):
+    """
+    Call cuOpt to get the optimal routing order for the nets.
+    Returns (order: list[int], raw_body: dict).
+    Falls back to Manhattan-distance greedy if API fails.
+    """
+    n_nets = len(pairs)
+    max_t = rows * cols + 4
+    cap = n_nets + 4
+
+    payload = {
+        "action": "cuOpt_OptimizedRouting",
+        "data": {
+            "cost_matrix_data": {"data": {"1": _cost_matrix(rows, cols, 1),
+                                          "2": _cost_matrix(rows, cols, 2)}},
+            "travel_time_matrix_data": {"data": {"1": _delay_matrix(rows, cols),
+                                                 "2": _delay_matrix(rows, cols)}},
+            "fleet_data": {
+                "vehicle_locations": [[0, 0], [0, 0]],
+                "vehicle_ids": ["M1_router", "M2_router"],
+                "capacities": [[cap, cap], [cap, cap]],
+                "vehicle_time_windows": [[0, max_t], [0, max_t]],
+                "vehicle_types": [1, 2],
+                "vehicle_max_costs": [rows * cols * 8, rows * cols * 8],
+                "vehicle_max_times": [max_t, max_t],
+                "skip_first_trips": [False, False],
+                "drop_return_trips": [True, True],
+                "min_vehicles": 1,
+            },
+            "task_data": {
+                "task_locations": [p["sink"] for p in pairs],
+                "task_ids": [p["name"] for p in pairs],
+                "demand": [[1] * n_nets, [1] * n_nets],
+                "task_time_windows": [[0, max_t]] * n_nets,
+                "service_times": [0] * n_nets,
+            },
+            "solver_config": {
+                "time_limit": 5,
+                "objectives": {
+                    "cost": 2,
+                    "travel_time": 1,
+                    "variance_route_size": 1,
+                    "variance_route_service_time": 0,
+                    "prize": 0,
+                },
+                "verbose_mode": False,
+                "error_logging": True,
+            },
+        },
+        "client_version": "chip_router_v3",
+    }
+
+    session = requests.Session()
+    resp = session.post(INVOKE_URL, headers=HEADERS, json=payload, timeout=30)
+    elapsed = 0
+    while resp.status_code == 202:
+        req_id = resp.headers.get("NVCF-REQID", "")
+        time.sleep(POLL_INTERVAL)
+        elapsed += POLL_INTERVAL
+        if elapsed > MAX_WAIT:
+            raise TimeoutError("cuOpt timed out")
+        resp = session.get(FETCH_URL_FMT.format(req_id), headers=HEADERS, timeout=30)
+    resp.raise_for_status()
+
+    body = resp.json()
+    vdata = body.get("response", {}).get("solver_response", {}).get("vehicle_data", {})
+    names = []
+    for vd in vdata.values():
+        for t in vd.get("task_id", []):
+            if str(t) != "Depot":
+                names.append(str(t))
+
+    name_to_idx = {p["name"]: i for i, p in enumerate(pairs)}
+    order = [name_to_idx[n] for n in names if n in name_to_idx]
+    for i in range(len(pairs)):
+        if i not in order:
+            order.append(i)
+    return order, body
+
+
+# ─── GUI ──────────────────────────────────────────────────────────────────────
+
+class App(tk.Tk):
+    def __init__(self):
+        super().__init__()
+        self.title("Chip Routing Optimizer — cuOpt + A*")
+        self.configure(bg=T["bg"])
+        self.geometry("1220x820")
+        self.resizable(True, True)
+
+        self.rows = 0
+        self.cols = 0
+        self.components = {}  # node_idx -> name
+        self.pairs = []  # [{name, src, sink, src_name, sink_name}]
+        self.routes = {}  # name -> [(r,c),...]
+        self.net_colors = {}  # name -> color
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.cell_items = {}  # node -> (rect, text, coord, sub)
+
+        self._build_ui()
+
+    # ── UI build ──────────────────────────────────────────────────────────────
+
+    def _build_ui(self):
+        self.left = tk.Frame(self, bg=T["panel"], width=248)
+        self.left.pack(side=tk.LEFT, fill=tk.Y)
+        self.left.pack_propagate(False)
+        self._build_panel()
+
+        right = tk.Frame(self, bg=T["bg"])
+        right.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+
+        cf = tk.Frame(right, bg=T["bg"])
+        cf.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
+        hs = tk.Scrollbar(cf, orient=tk.HORIZONTAL)
+        vs = tk.Scrollbar(cf, orient=tk.VERTICAL)
+        self.canvas = tk.Canvas(cf, bg=T["bg"], highlightthickness=0,
+                                xscrollcommand=hs.set, yscrollcommand=vs.set)
+        hs.config(command=self.canvas.xview)
+        vs.config(command=self.canvas.yview)
+        hs.pack(side=tk.BOTTOM, fill=tk.X)
+        vs.pack(side=tk.RIGHT, fill=tk.Y)
+        self.canvas.pack(fill=tk.BOTH, expand=True)
+
+        self.status_var = tk.StringVar(value="Enter grid dimensions and click Build.")
+        tk.Label(right, textvariable=self.status_var,
+                 bg=T["panel2"], fg=T["muted"],
+                 font=("Courier", 9), anchor=tk.W, padx=10, pady=5
+                 ).pack(fill=tk.X, side=tk.BOTTOM)
+
+    def _lbl(self, p, text, fg=None, size=9, bold=False):
+        tk.Label(p, text=text, bg=T["panel"],
+                 fg=fg or T["muted"],
+                 font=("Courier", size, "bold" if bold else "normal"),
+                 anchor=tk.W).pack(fill=tk.X, padx=12, pady=(2, 0))
+
+    def _sep(self, p):
+        tk.Frame(p, bg=T["border"], height=1).pack(fill=tk.X, pady=5)
+
+    def _btn(self, p, text, cmd, bg, fg=None, pady=6):
+        tk.Button(p, text=text, font=("Courier", 9, "bold"),
+                  bg=bg, fg=fg or T["bg"], relief=tk.FLAT,
+                  activebackground=bg, activeforeground=fg or T["bg"],
+                  command=cmd, cursor="hand2", pady=pady
+                  ).pack(fill=tk.X, padx=12, pady=3)
+
+    def _build_panel(self):
+        p = self.left
+        tk.Label(p, text="CHIP ROUTER", bg=T["panel"], fg=T["accent"],
+                 font=("Courier", 12, "bold")).pack(pady=(16, 1))
+        tk.Label(p, text="cuOpt order  ·  A* octilinear paths",
+                 bg=T["panel"], fg=T["muted"], font=("Courier", 7)).pack(pady=(0, 10))
+        self._sep(p)
+
+        # ① Grid
+        self._lbl(p, "① GRID SIZE", T["text"], 9, True)
+        gf = tk.Frame(p, bg=T["panel"]);
+        gf.pack(fill=tk.X, padx=12, pady=4)
+        for row_i, (lbl, var_name, default) in enumerate(
+                [("Rows", "rows_var", 6), ("Cols", "cols_var", 8)]):
+            tk.Label(gf, text=lbl, bg=T["panel"], fg=T["muted"],
+                     font=("Courier", 8)).grid(row=row_i, column=0, sticky=tk.W, pady=2)
+            v = tk.IntVar(value=default)
+            setattr(self, var_name, v)
+            tk.Spinbox(gf, from_=2, to=20, textvariable=v, width=5,
+                       bg=T["cell_empty"], fg=T["text"], relief=tk.FLAT,
+                       insertbackground=T["text"], buttonbackground=T["border"]
+                       ).grid(row=row_i, column=1, padx=8, pady=2)
+        self._btn(p, "▶  BUILD GRID", self._on_build, T["accent"])
+
+        self._sep(p)
+
+        # ② Components
+        self._lbl(p, "② PLACE COMPONENTS", T["text"], 9, True)
+        self._lbl(p, "Click cell → type name → Place")
+        ef = tk.Frame(p, bg=T["panel"]);
+        ef.pack(fill=tk.X, padx=12, pady=4)
+        tk.Label(ef, text="Name:", bg=T["panel"], fg=T["muted"],
+                 font=("Courier", 8)).pack(side=tk.LEFT)
+        self.comp_var = tk.StringVar()
+        self.comp_entry = tk.Entry(ef, textvariable=self.comp_var, width=13,
+                                   bg=T["cell_empty"], fg=T["text"], relief=tk.FLAT,
+                                   insertbackground=T["text"], font=("Courier", 9))
+        self.comp_entry.pack(side=tk.LEFT, padx=(4, 0))
+        self.comp_entry.bind("<Return>", lambda _: self._on_place())
+        bf = tk.Frame(p, bg=T["panel"]);
+        bf.pack(fill=tk.X, padx=12, pady=(0, 4))
+        for txt, cmd, col in [("Place", self._on_place, T["ok"]),
+                              ("Clear", self._on_clear, T["danger"])]:
+            tk.Button(bf, text=txt, font=("Courier", 8), bg=col, fg=T["bg"],
+                      relief=tk.FLAT, command=cmd, cursor="hand2",
+                      padx=8, pady=2).pack(side=tk.LEFT, padx=(0, 4))
+        self.sel_lbl = tk.Label(p, text="No cell selected",
+                                bg=T["panel"], fg=T["muted"],
+                                font=("Courier", 7), anchor=tk.W)
+        self.sel_lbl.pack(fill=tk.X, padx=12)
+
+        self._sep(p)
+
+        # ③ Pairs
+        self._lbl(p, "③ WIRE PAIRS", T["text"], 9, True)
+        self._lbl(p, "Toggle mode → click src → click sink")
+        self.pair_btn = tk.Button(
+            p, text="⛓  ENTER PAIR MODE",
+            font=("Courier", 8, "bold"),
+            bg=T["cell_empty"], fg=T["accent2"], relief=tk.FLAT,
+            activebackground=T["border"], activeforeground=T["accent2"],
+            command=self._toggle_pair, cursor="hand2", pady=4)
+        self.pair_btn.pack(fill=tk.X, padx=12, pady=4)
+        self.pair_hint = tk.Label(p, text="", bg=T["panel"], fg=T["warn"],
+                                  font=("Courier", 7), anchor=tk.W)
+        self.pair_hint.pack(fill=tk.X, padx=12)
+        self.pair_list_frame = tk.Frame(p, bg=T["panel"])
+        self.pair_list_frame.pack(fill=tk.X, padx=12, pady=4)
+
+        self._sep(p)
+
+        # ④ Route
+        self._lbl(p, "④ ROUTE", T["text"], 9, True)
+        self._btn(p, "⚡  RUN CUOPT + A*", self._on_run, T["accent2"])
+        self._btn(p, "↺  RESET", self._on_reset, T["muted"])
+
+        self._sep(p)
+        self._lbl(p, "LEGEND", T["muted"], 7, True)
+        for label, color in [
+            ("Orthogonal wire (90°)", T["accent"]),
+            ("Diagonal wire  (45°)", T["ok"]),
+            ("Via / bend point", T["warn"]),
+            ("Component cell", T["cell_comp"]),
+            ("Depot / origin", T["cell_depot"]),
+        ]:
+            lf = tk.Frame(p, bg=T["panel"]);
+            lf.pack(fill=tk.X, padx=12, pady=1)
+            tk.Canvas(lf, width=10, height=10, bg=color, highlightthickness=0
+                      ).pack(side=tk.LEFT)
+            tk.Label(lf, text=f" {label}", bg=T["panel"], fg=T["muted"],
+                     font=("Courier", 7)).pack(side=tk.LEFT)
+
+    # ── Grid draw ─────────────────────────────────────────────────────────────
+
+    def _render_grid(self):
+        self.canvas.delete("all")
+        self.cell_items = {}
+
+        tw = self.cols * CELL_W + GPAD * 2
+        th = self.rows * CELL_H + GPAD * 2
+        self.canvas.config(scrollregion=(0, 0, tw, th))
+
+        for r in range(self.rows):
+            for c in range(self.cols):
+                n = r * self.cols + c
+                x0 = GPAD + c * CELL_W
+                y0 = GPAD + r * CELL_H
+                x1 = x0 + CELL_W - 1
+                y1 = y0 + CELL_H - 1
+                cx = (x0 + x1) / 2
+                cy = (y0 + y1) / 2
+
+                col = self._cell_bg(n)
+                rid = self.canvas.create_rectangle(
+                    x0, y0, x1, y1, fill=col, outline=T["border"],
+                    width=1, tags=(f"c{n}", "cell"))
+
+                lbl = "DEPOT" if n == 0 else self.components.get(n, "")
+                lclr = T["accent2"] if n == 0 else (T["accent"] if lbl else T["muted"])
+                tid = self.canvas.create_text(
+                    cx, cy - 3, text=lbl,
+                    fill=lclr, font=("Courier", 8, "bold"),
+                    width=CELL_W - 6, anchor=tk.CENTER, tags=(f"c{n}",))
+
+                cid = self.canvas.create_text(
+                    x1 - 3, y1 - 3, text=f"{r},{c}",
+                    fill=T["muted"], font=("Courier", 6),
+                    anchor=tk.SE, tags=(f"c{n}",))
+
+                self.cell_items[n] = (rid, tid, cid)
+
+                for item in (rid, tid, cid):
+                    self.canvas.tag_bind(item, "<Button-1>",
+                                         lambda e, nd=n: self._click(nd))
+                    self.canvas.tag_bind(item, "<Enter>",
+                                         lambda e, nd=n: self._hover(nd, True))
+                    self.canvas.tag_bind(item, "<Leave>",
+                                         lambda e, nd=n: self._hover(nd, False))
+
+        self._redraw_routes()
+
+    def _cell_bg(self, n):
+        if n == 0:               return T["cell_depot"]
+        if n == self.pair_src:   return "#1a3040"
+        if n == self.sel_cell:   return T["cell_sel"]
+        if n in self.components: return T["cell_comp"]
+        return T["cell_empty"]
+
+    def _recolor(self, n):
+        if n in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[n][0], fill=self._cell_bg(n))
+
+    def _hover(self, n, on):
+        if n not in self.cell_items:
+            return
+        cur = self.canvas.itemcget(self.cell_items[n][0], "fill")
+        if on and cur == T["cell_empty"]:
+            self.canvas.itemconfig(self.cell_items[n][0], fill=T["cell_hover"])
+        else:
+            self._recolor(n)
+
+    # ── Route drawing — the key visual part ───────────────────────────────────
+
+    def _redraw_routes(self):
+        self.canvas.delete("route")
+        self.canvas.delete("via")
+
+        for i, p in enumerate(self.pairs):
+            name = p["name"]
+            color = self.net_colors.get(name, NET_COLORS[i % len(NET_COLORS)])
+            path = self.routes.get(name)
+
+            if path and len(path) >= 2:
+                # Draw each hop as a line segment
+                for seg in range(len(path) - 1):
+                    r1, c1 = path[seg]
+                    r2, c2 = path[seg + 1]
+                    dr = r2 - r1
+                    dc = c2 - c1
+                    is45 = abs(dr) == 1 and abs(dc) == 1
+
+                    px1 = GPAD + c1 * CELL_W + CELL_W // 2
+                    py1 = GPAD + r1 * CELL_H + CELL_H // 2
+                    px2 = GPAD + c2 * CELL_W + CELL_W // 2
+                    py2 = GPAD + r2 * CELL_H + CELL_H // 2
+
+                    # Solid for 90°, short-dash for 45°
+                    dash = (5, 2) if is45 else ()
+                    self.canvas.create_line(
+                        px1, py1, px2, py2,
+                        fill=color, width=3, dash=dash,
+                        capstyle=tk.ROUND, joinstyle=tk.ROUND,
+                        tags="route")
+
+                # Via dots at every direction change (bend)
+                for seg in range(1, len(path) - 1):
+                    r0, c0 = path[seg - 1]
+                    r1, c1 = path[seg]
+                    r2, c2 = path[seg + 1]
+                    if (r1 - r0, c1 - c0) != (r2 - r1, c2 - c1):
+                        vx = GPAD + c1 * CELL_W + CELL_W // 2
+                        vy = GPAD + r1 * CELL_H + CELL_H // 2
+                        self.canvas.create_oval(
+                            vx - 5, vy - 5, vx + 5, vy + 5,
+                            fill=T["warn"], outline=T["bg"], width=1,
+                            tags="via")
+
+                # Source terminal (large filled circle)
+                sr0, sc0 = path[0]
+                sx = GPAD + sc0 * CELL_W + CELL_W // 2
+                sy = GPAD + sr0 * CELL_H + CELL_H // 2
+                self.canvas.create_oval(sx - 6, sy - 6, sx + 6, sy + 6,
+                                        fill=color, outline=T["bg"], width=1,
+                                        tags="via")
+
+                # Sink terminal
+                er0, ec0 = path[-1]
+                ex = GPAD + ec0 * CELL_W + CELL_W // 2
+                ey = GPAD + er0 * CELL_H + CELL_H // 2
+                self.canvas.create_oval(ex - 6, ey - 6, ex + 6, ey + 6,
+                                        fill=color, outline=T["bg"], width=1,
+                                        tags="via")
+                # Arrow head at sink to show direction
+                self.canvas.create_oval(ex - 3, ey - 3, ex + 3, ey + 3,
+                                        fill=T["bg"], outline="",
+                                        tags="via")
+
+                # Net label at midpoint
+                mid = len(path) // 2
+                mr, mc = path[mid]
+                mx = GPAD + mc * CELL_W + CELL_W // 2
+                my = GPAD + mr * CELL_H + CELL_H // 2
+                self.canvas.create_text(mx, my - 10, text=name,
+                                        fill=color, font=("Courier", 7, "bold"),
+                                        tags="route")
+
+            else:
+                # No routed path yet — draw a dashed preview arrow
+                sr, sc = divmod(p["src"], self.cols)
+                dr_, dc_ = divmod(p["sink"], self.cols)
+                sx = GPAD + sc * CELL_W + CELL_W // 2
+                sy = GPAD + sr * CELL_H + CELL_H // 2
+                dx = GPAD + dc_ * CELL_W + CELL_W // 2
+                dy = GPAD + dr_ * CELL_H + CELL_H // 2
+                self.canvas.create_line(
+                    sx, sy, dx, dy,
+                    fill=color, width=1, dash=(3, 4),
+                    arrow=tk.LAST, arrowshape=(7, 9, 3),
+                    tags="route")
+                mx_, my_ = (sx + dx) / 2, (sy + dy) / 2
+                self.canvas.create_text(mx_, my_ - 7, text=name,
+                                        fill=color, font=("Courier", 7),
+                                        tags="route")
+
+        self.canvas.tag_raise("route")
+        self.canvas.tag_raise("via")
+
+    # ── Cell click ────────────────────────────────────────────────────────────
+
+    def _click(self, n):
+        if self.mode == "edit":
+            if self.sel_cell is not None:
+                self._recolor(self.sel_cell)
+            self.sel_cell = n
+            self._recolor(n)
+            r, c = divmod(n, self.cols)
+            nm = self.components.get(n, "")
+            self.comp_var.set(nm)
+            self.comp_entry.focus_set()
+            if n == 0:
+                self.sel_lbl.config(text=f"({r},{c}) — depot/origin")
+            else:
+                self.sel_lbl.config(text=f"({r},{c}) · {nm or 'unnamed'}")
+            self._set_status(f"Selected ({r},{c}). Type name + Enter to place.")
+
+        elif self.mode == "pair":
+            if self.pair_src is None:
+                self.pair_src = n
+                self._recolor(n)
+                r, c = divmod(n, self.cols)
+                nm = self.components.get(n, "DEPOT" if n == 0 else f"node{n}")
+                self.pair_hint.config(text=f"Src: {nm} ({r},{c}) → now pick sink")
+            else:
+                if n == self.pair_src:
+                    self._recolor(n)
+                    self.pair_src = None
+                    self.pair_hint.config(text="Cleared. Pick source again.")
+                    return
+                def_name = f"NET{len(self.pairs)}"
+                net_name = simpledialog.askstring(
+                    "Net name", "Name for this wire connection:",
+                    initialvalue=def_name, parent=self)
+                if not net_name:
+                    net_name = def_name
+                net_name = net_name.strip().upper().replace(" ", "_")
+                src_name = self.components.get(self.pair_src,
+                                               "DEPOT" if self.pair_src == 0 else f"N{self.pair_src}")
+                sink_name = self.components.get(n,
+                                                "DEPOT" if n == 0 else f"N{n}")
+                ci = len(self.pairs) % len(NET_COLORS)
+                self.net_colors[net_name] = NET_COLORS[ci]
+                self.pairs.append({"name": net_name, "src": self.pair_src,
+                                   "sink": n, "src_name": src_name,
+                                   "sink_name": sink_name})
+                prev = self.pair_src
+                self.pair_src = None
+                self._recolor(prev)
+                self.pair_hint.config(text=f"'{net_name}' added. Pick next src →")
+                self._refresh_pairs()
+                self._redraw_routes()
+                self._set_status(f"Pair '{net_name}' added ({len(self.pairs)} total).")
+
+    # ── Component actions ─────────────────────────────────────────────────────
+
+    def _on_place(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            self._set_status("Select a non-depot cell first.")
+            return
+        name = self.comp_var.get().strip()
+        if not name:
+            self._set_status("Enter a component name.")
+            return
+        self.components[self.sel_cell] = name
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1],
+                                   text=name, fill=T["accent"])
+            self._recolor(self.sel_cell)
+        r, c = divmod(self.sel_cell, self.cols)
+        self._set_status(f"Placed '{name}' at ({r},{c}).")
+        for p in self.pairs:
+            if p["src"] == self.sel_cell: p["src_name"] = name
+            if p["sink"] == self.sel_cell: p["sink_name"] = name
+        self._refresh_pairs()
+
+    def _on_clear(self):
+        if self.sel_cell is None or self.sel_cell == 0:
+            return
+        self.components.pop(self.sel_cell, None)
+        if self.sel_cell in self.cell_items:
+            self.canvas.itemconfig(self.cell_items[self.sel_cell][1], text="")
+            self._recolor(self.sel_cell)
+        self.comp_var.set("")
+
+    # ── Pair mode ─────────────────────────────────────────────────────────────
+
+    def _toggle_pair(self):
+        if not self.rows:
+            self._set_status("Build a grid first.")
+            return
+        if self.mode == "edit":
+            self.mode = "pair"
+            self.pair_btn.config(text="✕  EXIT PAIR MODE",
+                                 bg=T["accent2"], fg=T["bg"])
+            self.pair_hint.config(text="Click a source cell →")
+            self._set_status("Pair mode: click source, then sink to add a wire pair.")
+        else:
+            self.mode = "edit"
+            if self.pair_src is not None:
+                self._recolor(self.pair_src)
+            self.pair_src = None
+            self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                                 bg=T["cell_empty"], fg=T["accent2"])
+            self.pair_hint.config(text="")
+            self._set_status("Edit mode.")
+
+    def _refresh_pairs(self):
+        for w in self.pair_list_frame.winfo_children():
+            w.destroy()
+        for i, p in enumerate(self.pairs):
+            color = self.net_colors.get(p["name"], NET_COLORS[i % len(NET_COLORS)])
+            row = tk.Frame(self.pair_list_frame, bg=T["panel2"])
+            row.pack(fill=tk.X, pady=1)
+            tk.Canvas(row, width=8, height=8, bg=color, highlightthickness=0
+                      ).pack(side=tk.LEFT, padx=(4, 3), pady=3)
+            tk.Label(row,
+                     text=f"{p['name']}: {p['src_name']} → {p['sink_name']}",
+                     bg=T["panel2"], fg=T["text"],
+                     font=("Courier", 7), anchor=tk.W
+                     ).pack(side=tk.LEFT, fill=tk.X, expand=True)
+            tk.Button(row, text="✕", bg=T["panel2"], fg=T["danger"],
+                      font=("Courier", 7), relief=tk.FLAT, cursor="hand2",
+                      command=lambda idx=i: self._remove_pair(idx)
+                      ).pack(side=tk.RIGHT, padx=2)
+
+    def _remove_pair(self, idx):
+        if 0 <= idx < len(self.pairs):
+            name = self.pairs[idx]["name"]
+            self.pairs.pop(idx)
+            self.routes.pop(name, None)
+            self._refresh_pairs()
+            self._redraw_routes()
+
+    # ── Run routing ───────────────────────────────────────────────────────────
+
+    def _on_run(self):
+        if not self.rows:
+            messagebox.showerror("No grid", "Build a grid first.")
+            return
+        if not self.pairs:
+            messagebox.showerror("No pairs", "Add at least one wire pair.")
+            return
+
+        self._set_status("Sending net list to NVIDIA cuOpt to optimise routing order…")
+        self.update()
+
+        try:
+            order, cuopt_body = cuopt_net_order(self.rows, self.cols, self.pairs)
+        except Exception as e:
+            self._set_status(f"cuOpt error: {e}  — falling back to greedy order.")
+            order = list(range(len(self.pairs)))
+            cuopt_body = {}
+
+        self._set_status(
+            f"Running A* octilinear router for {len(self.pairs)} nets…")
+        self.update()
+
+        self.routes = route_all_nets(
+            self.pairs, self.rows, self.cols, self.components, order=order)
+
+        self._render_grid()
+
+        routed = sum(1 for v in self.routes.values() if v)
+        self._set_status(
+            f"Done. {routed}/{len(self.pairs)} nets routed. "
+            f"Solid = 90°, dashed = 45°, yellow dot = via/bend.")
+
+        self._show_result_popup()
+
+    def _show_result_popup(self):
+        win = tk.Toplevel(self)
+        win.title("Routing Results")
+        win.configure(bg=T["bg"])
+        win.geometry("580x460")
+
+        tk.Label(win, text="ROUTING RESULTS", bg=T["bg"], fg=T["accent"],
+                 font=("Courier", 11, "bold")).pack(pady=(14, 6))
+
+        frm = tk.Frame(win, bg=T["bg"])
+        frm.pack(fill=tk.BOTH, expand=True, padx=14)
+        sb = tk.Scrollbar(frm);
+        sb.pack(side=tk.RIGHT, fill=tk.Y)
+        txt = tk.Text(frm, bg=T["panel"], fg=T["text"], font=("Courier", 8),
+                      relief=tk.FLAT, yscrollcommand=sb.set)
+        txt.pack(fill=tk.BOTH, expand=True)
+        sb.config(command=txt.yview)
+
+        total = 0
+        for i, p in enumerate(self.pairs):
+            path = self.routes.get(p["name"], [])
+            wire_len = len(path) - 1 if path else 0
+            total += wire_len
+
+            # count bends
+            bends = 0
+            for seg in range(1, len(path) - 1):
+                r0, c0 = path[seg - 1]
+                r1, c1 = path[seg]
+                r2, c2 = path[seg + 1]
+                if (r1 - r0, c1 - c0) != (r2 - r1, c2 - c1):
+                    bends += 1
+
+            # count 45° hops
+            diag45 = sum(
+                1 for s in range(len(path) - 1)
+                if abs(path[s][0] - path[s + 1][0]) == 1
+                and abs(path[s][1] - path[s + 1][1]) == 1
+            )
+            ortho = wire_len - diag45
+
+            status = "ROUTED  " if path else "UNROUTED"
+            src_rc = divmod(p["src"], self.cols)
+            sink_rc = divmod(p["sink"], self.cols)
+            line = (
+                f"[{status}] {p['name']:<12}  "
+                f"{p['src_name']:<10} ({src_rc[0]},{src_rc[1]}) "
+                f"→ {p['sink_name']:<10} ({sink_rc[0]},{sink_rc[1]})\n"
+                f"          wire: {wire_len} hops "
+                f"({ortho} ortho + {diag45} diag)   "
+                f"bends: {bends}\n\n"
+            )
+            txt.insert(tk.END, line)
+
+        txt.insert(tk.END, f"Total wire length : {total} hops\n")
+        txt.config(state=tk.DISABLED)
+
+        tk.Button(win, text="Close", bg=T["accent"], fg=T["bg"],
+                  font=("Courier", 9, "bold"), relief=tk.FLAT,
+                  command=win.destroy, cursor="hand2", pady=6
+                  ).pack(pady=(8, 14))
+
+    # ── Build / Reset ─────────────────────────────────────────────────────────
+
+    def _on_build(self):
+        self.rows = max(2, min(20, self.rows_var.get()))
+        self.cols = max(2, min(20, self.cols_var.get()))
+        self.components = {}
+        self.pairs = []
+        self.routes = {}
+        self.net_colors = {}
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                             bg=T["cell_empty"], fg=T["accent2"])
+        self.pair_hint.config(text="")
+        self.sel_lbl.config(text="No cell selected")
+        self.comp_var.set("")
+        self._render_grid()
+        self._refresh_pairs()
+        self._set_status(
+            f"Grid {self.rows}×{self.cols} ready. "
+            "Click cells to place components.")
+
+    def _on_reset(self):
+        self.components = {}
+        self.pairs = []
+        self.routes = {}
+        self.net_colors = {}
+        self.sel_cell = None
+        self.pair_src = None
+        self.mode = "edit"
+        self.pair_btn.config(text="⛓  ENTER PAIR MODE",
+                             bg=T["cell_empty"], fg=T["accent2"])
+        self.pair_hint.config(text="")
+        self.sel_lbl.config(text="No cell selected")
+        self.comp_var.set("")
+        if self.rows:
+            self._render_grid()
+        self._refresh_pairs()
+        self._set_status("Reset. Place components and create wire pairs.")
+
+    def _set_status(self, msg):
+        self.status_var.set(f"  {msg}")
 
-app = FastAPI()
 
+# ─── Entry ────────────────────────────────────────────────────────────────────
 
-@app.get("/")
-def greet_json():
-    return {"Hello": "World!"}
+if __name__ == "__main__":
+    App().mainloop()