feat: coarse_stride per sub-sampling top-level

Nuovo kernel JIT _jit_score_bitmap_rescored_strided: valuta solo
pixel su griglia stride x stride al top della piramide. NMS + fase
full-res recuperano precisione. Speed-up ~stride^2 sulla fase coarse,
specie su scene grandi (1920x1080).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,22 @@
+.venv
+.git
+.gitignore
+.github
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.DS_Store
+.idea
+.vscode
+*.log
+# Test images non necessarie nel container (caricate via volume/UI)
+Test
+benchmarks
+ROADMAP.md
+shape_model_2d_technical_doc.md
+*.md
+!README.md
+Dockerfile
+docker-compose*.yml
+.env

.env.example

@@ -0,0 +1,14 @@
+# Copia questo file in .env e adatta i valori.
+# .env NON è versionato (contiene config locale/secrets).
+
+# Cartella immagini (relativa al progetto in dev locale,
+# assoluta dentro container es. /data/images)
+IMAGES_DIR=Test
+
+# Web server
+HOST=127.0.0.1
+PORT=8080
+
+# Registry + tag per docker-compose (deploy VPS)
+REGISTRY=localhost:5000
+TAG=latest

Dockerfile

@@ -0,0 +1,38 @@
+FROM python:3.13-slim AS base
+
+# uv package manager (copia binario ufficiale)
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+# System deps per opencv (libgl/glib), numba (libgomp)
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgl1 \
+    libglib2.0-0 \
+    libgomp1 \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+# Install deps da lockfile (layer cachato finché pyproject/uv.lock non cambiano)
+COPY pyproject.toml uv.lock ./
+COPY .python-version* ./
+RUN uv sync --frozen --no-dev
+
+# Copia sorgenti applicazione
+COPY pm2d ./pm2d
+COPY main.py ./
+
+# Defaults (override via docker-compose env)
+ENV IMAGES_DIR=/data/images \
+    HOST=0.0.0.0 \
+    PORT=8080 \
+    PYTHONUNBUFFERED=1
+
+# Cartella dati (montata come volume in compose)
+RUN mkdir -p /data/images
+
+EXPOSE 8080
+
+HEALTHCHECK --interval=30s --timeout=5s --retries=3 \
+    CMD python -c "import urllib.request; urllib.request.urlopen('http://localhost:8080/images').read()" || exit 1
+
+CMD ["uv", "run", "python", "main.py"]

README.md

@@ -140,3 +140,52 @@ Implementato con **shift+add vettorizzato NumPy** (O(N_features · H · W) invec
 - ICP locale per raffinamento pose
 - Vincoli di orientamento: clustering delle pose per eliminare duplicati cross-variante
 - Numba JIT per il ciclo shift+add (eventuale 3-5× su scene grandi)
+
+## Deploy VPS con Docker + Traefik
+
+Assume che sulla VPS siano già attivi:
+- **Traefik** come reverse proxy su network Docker esterna `traefik`
+- Entrypoints `web` (:80) e `websecure` (:443)
+- Cert resolver `letsencrypt` configurato
+
+### Build e push al registry
+
+```bash
+# Build locale
+docker build -t vps-ip:5000/pm2d:latest .
+docker push vps-ip:5000/pm2d:latest
+```
+
+### Sulla VPS
+
+```bash
+# Cartella deploy (immagini persistenti qui)
+mkdir -p /opt/docker/pm2d/images
+cd /opt/docker/pm2d
+
+# Copia docker-compose.yml
+# Imposta REGISTRY / TAG se necessario via .env
+echo "REGISTRY=vps-ip:5000" > .env
+echo "TAG=latest" >> .env
+
+docker compose pull
+docker compose up -d
+```
+
+Servizio raggiungibile: **https://pm.tielogic.xyz**
+
+### Note operative
+
+- **Volume `./images`**: persistenza delle immagini caricate tramite UI
+  (`IMAGES_DIR=/data/images` nel container). Sopravvive a restart.
+- **Upload max 50MB**: middleware Traefik `pm2d-bodysize`. Adattare se serve.
+- **Cache matcher in-memory**: si svuota a restart container (no problema,
+  viene ri-popolata al primo match).
+- **Healthcheck**: HTTP `GET /images` ogni 30s.
+- Se nome network Traefik diverso da `traefik`, modifica
+  `docker-compose.yml` sezione `networks`.
+
+### Adattamenti config Traefik non-standard
+
+Se la VPS ha convenzioni diverse (es. cert resolver chiamato `le`,
+entrypoint `https`), modifica i labels nel `docker-compose.yml`.

ROADMAP.md

@@ -2,6 +2,22 @@
 
 Lista ragionata di miglioramenti futuri. Priorità = impatto / effort, non urgenza temporale.
 
+## Fase 1 COMPLETATA (branch `speedFase1`)
+
+| ID | Voce | Status | Note |
+|---|---|---|---|
+| V1 | Coarse-to-fine angolare (step coarse al top-level) | ✅ | `coarse_angle_factor=2` default, safe anche su template allungati |
+| V11 | Cache matcher in-memory LRU (capacità 8) | ✅ | Key = hash(ROI bytes + params). Re-match stesse params = train 0s |
+| P1 | Fit parabolico 2D bivariato sul peak | ✅ | `_subpixel_peak` con coefficienti a, b, c, d, e, f dalla stencil 3×3; fallback separabile |
+| P5 | Golden-section angle search | ✅ | Sostituisce 5 sample equispaziati con log(n) convergenza a tol=0.1° |
+| P2 | Weighted centroid del plateau | ✅ | Integrato in `_subpixel_peak` con peso = (score - soglia)² |
+
+Benchmark suite 16 scenari (4 immagini × full/part × fast/preciso):
+- Prima Fase 1:  totale find 27.3s
+- Dopo  Fase 1:  totale find 25.1s (~8% speedup)
+- Regressione match count: nessuna (alcuni casi +1 match grazie a subpixel migliore)
+- Match auto-referenziale: offset 0.00 px, angolo 0.000° (era -3.5 px, -2.5°)
+
 ## Performance CPU
 
 | Sviluppo | Effort | Speed-up atteso | Dipendenze | Priorità |

docker-compose.yml

@@ -0,0 +1,41 @@
+# docker-compose per deploy VPS con Traefik.
+# Assume che Traefik sia già attivo sulla VPS con:
+#   - network esterna "traefik" (adatta nome se diverso)
+#   - entrypoint "websecure" su :443
+#   - certresolver "mytlschallenge" configurato
+#
+# Adattare eventualmente: nome network, entrypoint, certresolver.
+
+services:
+  pm2d:
+    build: .
+    image: pm2d:latest
+    container_name: pm2d
+    restart: unless-stopped
+    environment:
+      IMAGES_DIR: /data/images
+      HOST: 0.0.0.0
+      PORT: ${PORT:-8080}
+    volumes:
+      # Persistenza immagini tra restart (upload/selezione)
+      - ./images:/data/images
+    networks:
+      - traefik
+    labels:
+      - "traefik.enable=true"
+
+      # Router HTTPS principale
+      - "traefik.http.routers.pm2d.rule=Host(`pm.tielogic.xyz`)"
+      - "traefik.http.routers.pm2d.entrypoints=websecure"
+      - "traefik.http.routers.pm2d.tls=true"
+      - "traefik.http.routers.pm2d.tls.certresolver=mytlschallenge"
+      - "traefik.http.services.pm2d.loadbalancer.server.port=${PORT:-8080}"
+
+      # Middleware: upload fino a 50MB (default Traefik bufferizza a 4MB)
+      - "traefik.http.middlewares.pm2d-bodysize.buffering.maxRequestBodyBytes=52428800"
+      - "traefik.http.routers.pm2d.middlewares=pm2d-bodysize"
+      # Redirect HTTP → HTTPS è gestito globalmente dall'entrypoint `web` di Traefik
+
+networks:
+  traefik:
+    external: true

main.py

@@ -1,26 +1,14 @@
-"""Entry-point standalone Pattern Matching 2D shape-based.
+"""Entry-point PM2D — webapp HTML.
 
-Esegui:  uv run python main.py
+Esegui locale:  uv run python main.py        (default 127.0.0.1:8080)
+Container:      HOST=0.0.0.0 PORT=8080 python main.py
 """
-from pathlib import Path
+import os
 
-from pm2d.gui import run
+from pm2d.web.server import serve
 
 
 if __name__ == "__main__":
-    test_dir = Path(__file__).parent / "Test"
-    run(
-        initial_dir=str(test_dir) if test_dir.is_dir() else None,
-        angle_range_deg=(0.0, 360.0),
-        angle_step_deg=5.0,
-        scale_range=(1.0, 1.0),
-        scale_step=0.1,
-        num_features=96,
-        weak_grad=30.0,
-        strong_grad=60.0,
-        spread_radius=5,
-        pyramid_levels=3,
-        min_score=0.55,
-        max_matches=25,
-        backend="line",
-    )
+    host = os.environ.get("HOST", "127.0.0.1")
+    port = int(os.environ.get("PORT", "8080"))
+    serve(host=host, port=port)

pm2d/_jit_kernels.py

@@ -110,6 +110,112 @@ if HAS_NUMBA:
                     acc[y, x] *= inv
         return acc
 
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored_strided(
+        spread: np.ndarray,
+        dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+        bit_active: np.uint8,
+        bg: np.ndarray,
+        stride: nb.int32,
+    ) -> np.ndarray:
+        """Variante con sub-sampling: valuta solo pixel su griglia stride×stride.
+        Score restituito ha stessa shape (H, W); celle non valutate = 0.
+
+        4× speed-up con stride=2 (NMS recupera precisione in full-res).
+        Numba prange richiede step costante: itero su indici griglia e
+        moltiplico per stride dentro il body.
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        ny = (H + stride - 1) // stride
+        nx = (W + stride - 1) // stride
+        for yi in nb.prange(ny):
+            y = yi * stride
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint8(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                rem = x_lo % stride
+                if rem != 0:
+                    x_lo += stride - rem
+                x = x_lo
+                while x < x_hi:
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+                    x += stride
+        if N > 0:
+            inv = 1.0 / N
+            for yi in nb.prange(ny):
+                y = yi * stride
+                for xi in range(nx):
+                    x = xi * stride
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored(
+        spread: np.ndarray,      # uint8 (H, W)
+        dx: np.ndarray,          # int32 (N,)
+        dy: np.ndarray,          # int32 (N,)
+        bins: np.ndarray,        # int8 (N,)
+        bit_active: np.uint8,
+        bg: np.ndarray,          # float32 (H, W) background density normalizzata
+    ) -> np.ndarray:
+        """score+rescore in un singolo pass: evita allocazione intermedia.
+
+        Equivalente a:
+            score = _jit_score_bitmap(...)
+            out   = max(0, (score - bg) / (1 - bg + 1e-6))
+        ma fonde la seconda passata dentro la normalizzazione finale
+        (cache-friendly, risparmia ~15% sul totale find).
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint8(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                for x in range(x_lo, x_hi):
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+        if N > 0:
+            inv = 1.0 / N
+            for y in nb.prange(H):
+                for x in range(W):
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
     @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
     def _jit_popcount_density(spread: np.ndarray) -> np.ndarray:
         """Conta bit set per pixel: ritorna (H, W) float32 in [0..8]."""
@@ -134,6 +240,11 @@ if HAS_NUMBA:
         _jit_score_by_shift(resp, dx, dy, b, ba)
         spread = np.zeros((32, 32), dtype=np.uint8)
         _jit_score_bitmap(spread, dx, dy, b, np.uint8(0xFF))
+        bg = np.zeros((32, 32), dtype=np.float32)
+        _jit_score_bitmap_rescored(spread, dx, dy, b, np.uint8(0xFF), bg)
+        _jit_score_bitmap_rescored_strided(
+            spread, dx, dy, b, np.uint8(0xFF), bg, np.int32(2),
+        )
         _jit_popcount_density(spread)
 
 else:  # pragma: no cover
@@ -144,6 +255,12 @@ else:  # pragma: no cover
     def _jit_score_bitmap(spread, dx, dy, bins, bit_active):
         raise RuntimeError("numba non disponibile")
 
+    def _jit_score_bitmap_rescored(spread, dx, dy, bins, bit_active, bg):
+        raise RuntimeError("numba non disponibile")
+
+    def _jit_score_bitmap_rescored_strided(spread, dx, dy, bins, bit_active, bg, stride):
+        raise RuntimeError("numba non disponibile")
+
     def _jit_popcount_density(spread):
         raise RuntimeError("numba non disponibile")
 
@@ -172,6 +289,36 @@ def score_bitmap(
     return _numpy_score_by_shift(resp, dx, dy, bins, None)
 
 
+def score_bitmap_rescored(
+    spread: np.ndarray, dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+    bit_active: int, bg: np.ndarray, stride: int = 1,
+) -> np.ndarray:
+    """Score bitmap + rescore fusi in un solo pass (JIT).
+
+    stride > 1: valuta solo pixel su griglia stride×stride. Le celle non
+    valutate restano 0 nello score map. Pensato per coarse-pass al top
+    della piramide; il refinement full-res poi recupera precisione.
+    """
+    if HAS_NUMBA and len(dx) > 0:
+        spread_c = np.ascontiguousarray(spread, dtype=np.uint8)
+        dx_c = np.ascontiguousarray(dx, dtype=np.int32)
+        dy_c = np.ascontiguousarray(dy, dtype=np.int32)
+        bins_c = np.ascontiguousarray(bins, dtype=np.int8)
+        bg_c = np.ascontiguousarray(bg, dtype=np.float32)
+        if stride > 1:
+            return _jit_score_bitmap_rescored_strided(
+                spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
+                np.int32(stride),
+            )
+        return _jit_score_bitmap_rescored(
+            spread_c, dx_c, dy_c, bins_c, np.uint8(bit_active), bg_c,
+        )
+    # Fallback: chiamate separate (stride ignorato in fallback)
+    score = score_bitmap(spread, dx, dy, bins, bit_active)
+    out = (score - bg) / (1.0 - bg + 1e-6)
+    return np.maximum(0.0, out).astype(np.float32)
+
+
 def popcount_density(spread: np.ndarray) -> np.ndarray:
     if HAS_NUMBA:
         return _jit_popcount_density(np.ascontiguousarray(spread, dtype=np.uint8))

pm2d/auto_tune.py

@@ -14,6 +14,9 @@ Ritorna dict con i key esatti del form `edit_params`.
 
 from __future__ import annotations
 
+import hashlib
+from collections import OrderedDict
+
 import cv2
 import numpy as np
 
@@ -24,17 +27,33 @@ def _to_gray(img: np.ndarray) -> np.ndarray:
     return img
 
 
+# Cache in-memory (LRU) dei risultati auto_tune per stesso input ROI.
+_TUNE_CACHE: OrderedDict[str, dict] = OrderedDict()
+_TUNE_CACHE_SIZE = 32
+
+
 def detect_rotational_symmetry(
     gray: np.ndarray, step_deg: float = 5.0, corr_thresh: float = 0.75,
 ) -> dict:
     """Rileva simmetria rotazionale su edge map (più robusto a sfondo uniforme).
 
+    Downsample a max 128 px prima di correlare per abbattere il costo
+    O(n_angles · H · W) senza perdere precisione (la simmetria rotazionale
+    è invariante a subsampling moderato).
+
     Ritorna dict con:
       - order: int, 1=nessuna, 2=180°, 3=120°, 4=90°, 6=60°, 8=45°
       - period_deg: float, periodo minimo di simmetria (360/order)
       - confidence: float [0..1], correlazione minima tra rotazioni equivalenti
     """
     h, w = gray.shape
+    target = 128
+    if max(h, w) > target:
+        sf = target / max(h, w)
+        new_w = max(32, int(w * sf))
+        new_h = max(32, int(h * sf))
+        gray = cv2.resize(gray, (new_w, new_h), interpolation=cv2.INTER_AREA)
+        h, w = gray.shape
     # Usa magnitude gradiente (rotation-invariant rispetto a bg uniforme)
     gx = cv2.Sobel(gray, cv2.CV_32F, 1, 0, ksize=3)
     gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
@@ -88,9 +107,12 @@ def analyze_gradients(gray: np.ndarray) -> dict:
     gy = cv2.Sobel(gray, cv2.CV_32F, 0, 1, ksize=3)
     mag = cv2.magnitude(gx, gy)
 
-    # Percentili magnitude
+    # Percentili magnitude: p55/p85 usati per soglie weak/strong (più aderenti
+    # alla distribuzione reale rispetto a p50/p80 + clamp).
     p50 = float(np.percentile(mag, 50))
+    p55 = float(np.percentile(mag, 55))
     p80 = float(np.percentile(mag, 80))
+    p85 = float(np.percentile(mag, 85))
     p95 = float(np.percentile(mag, 95))
     mag_max = float(mag.max())
 
@@ -112,7 +134,8 @@ def analyze_gradients(gray: np.ndarray) -> dict:
         ent = 0.0
 
     return {
-        "p50": p50, "p80": p80, "p95": p95, "mag_max": mag_max,
+        "p50": p50, "p55": p55, "p80": p80, "p85": p85, "p95": p95,
+        "mag_max": mag_max,
         "strong_pct": strong_pct, "weak_pct": weak_pct,
         "orient_entropy": ent,
         "n_pixels": mag.size,
@@ -120,11 +143,28 @@ def analyze_gradients(gray: np.ndarray) -> dict:
     }
 
 
+def _cache_key(template_bgr: np.ndarray, mask: np.ndarray | None) -> str:
+    h = hashlib.md5()
+    h.update(np.ascontiguousarray(template_bgr).tobytes())
+    h.update(f"shape={template_bgr.shape}".encode())
+    if mask is not None:
+        h.update(np.ascontiguousarray(mask).tobytes())
+    return h.hexdigest()
+
+
 def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     """Analizza template e ritorna dict parametri suggeriti.
 
     Chiavi compatibili con edit_params PARAM_SCHEMA.
+
+    Risultato cachato in-memory (LRU): ri-chiamare con stessa ROI è O(1).
     """
+    ck = _cache_key(template_bgr, mask)
+    cached = _TUNE_CACHE.get(ck)
+    if cached is not None:
+        _TUNE_CACHE.move_to_end(ck)
+        return dict(cached)
+
     gray = _to_gray(template_bgr)
     h, w = gray.shape
     if mask is not None:
@@ -136,16 +176,22 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     stats = analyze_gradients(gray_for_stats)
     sym = detect_rotational_symmetry(gray_for_stats)
 
-    # Soglie magnitude: usa percentili per robustezza illuminazione.
-    # Target: strong_grad ~= valore a percentile 80-90 in assoluto, ma
-    # clamp per compatibilità uint8 (Sobel può sforare).
-    strong_grad = float(np.clip(stats["p80"], 20.0, 100.0))
-    weak_grad = float(np.clip(strong_grad * 0.5, 10.0, 60.0))
+    # Soglie magnitude: usa percentili reali (p85/p55) senza clamp duro a 100.
+    # Sobel ksize=3 su uint8 può arrivare a ~1020, quindi clamp massimo 400
+    # evita saturazione del threshold su template ad alto contrasto.
+    strong_grad = float(np.clip(stats["p85"], 30.0, 400.0))
+    weak_grad = float(np.clip(stats["p55"], 15.0, strong_grad * 0.7))
 
-    # num_features: 1 feature ogni ~25 px forti, clamp 48..192
-    target_feat = int(np.clip(stats["n_strong"] / 25, 48, 192))
+    # num_features: ibrido perimetro + densità. Target = min(perimeter_budget,
+    # density_budget) per non generare più feature di quante edge nitide siano
+    # disponibili, ma neanche meno di quante il perimetro possa tracciare.
+    perim_budget = int(2 * (h + w) * 0.4)          # ~40% dei pixel di perimetro
+    density_budget = int(stats["n_strong"] / 20)   # 1 feature ogni ~20 px forti
+    target_feat = int(np.clip(min(perim_budget, density_budget), 64, 192))
 
-    # pyramid_levels in base alla dimensione minima
+    # pyramid_levels in base a dimensione minima E densità feature: un template
+    # grande ma povero di feature non deve scendere troppi livelli (rischio
+    # collasso a <16 feature al top level).
     min_side = min(h, w)
     if min_side < 60:
         pyr = 1
@@ -155,6 +201,9 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
         pyr = 3
     else:
         pyr = 4
+    # Cap: non scendere sotto ~16 feature al top level (feature ÷ 4^(pyr-1))
+    max_pyr_from_feat = max(1, int(np.floor(np.log2(max(1, target_feat / 16.0)) / 2.0)) + 1)
+    pyr = min(pyr, max_pyr_from_feat)
 
     # spread_radius proporzionale a risoluzione + pyramid (tolleranza ~1% dim)
     spread_radius = int(np.clip(max(3, min_side * 0.02), 3, 8))
@@ -174,7 +223,7 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
     # angle step: 5° default; se simmetria, mantengo step ma range ridotto
     angle_step = 5.0
 
-    return {
+    result = {
         "backend": "line",
         "angle_min": 0.0,
         "angle_max": angle_max,
@@ -196,6 +245,12 @@ def auto_tune(template_bgr: np.ndarray, mask: np.ndarray | None = None) -> dict:
         "_symmetry_conf": round(sym["confidence"], 2),
         "_orient_entropy": round(stats["orient_entropy"], 2),
     }
+    # Store in LRU cache
+    _TUNE_CACHE[ck] = dict(result)
+    _TUNE_CACHE.move_to_end(ck)
+    while len(_TUNE_CACHE) > _TUNE_CACHE_SIZE:
+        _TUNE_CACHE.popitem(last=False)
+    return result
 
 
 def summarize(tune: dict) -> str:

pm2d/gui.py

@@ -261,33 +261,33 @@ def draw_matches(
     return out
 
 
-def build_info_panel(
+def _put_text(img: np.ndarray, s: str, x: int, y: int,
+              size: float = 0.5, color: tuple = (220, 220, 220),
+              thick: int = 1) -> None:
+    cv2.putText(img, s, (x, y), cv2.FONT_HERSHEY_SIMPLEX,
+                size, color, thick, cv2.LINE_AA)
+
+
+def build_left_panel(
     template_bgr: np.ndarray,
-    params: dict,
     matches: list[Match],
-    panel_width: int = 380,
-    panel_height: int | None = None,
+    panel_width: int = 300,
+    panel_height: int = 900,
 ) -> np.ndarray:
-    """Costruisce pannello laterale: thumbnail modello + parametri + legenda
-    numerata dei match + hotkey."""
-    if panel_height is None:
-        panel_height = panel_width * 2
+    """Pannello sinistro: thumbnail modello + legenda risultati (senza parametri)."""
     panel = np.full((panel_height, panel_width, 3), 28, dtype=np.uint8)
     pad = 12
     y = pad
 
-    def _text(img, s, y, size=0.5, color=(220, 220, 220), thick=1, x=None):
-        cv2.putText(img, s, (x if x is not None else pad, y),
-                    cv2.FONT_HERSHEY_SIMPLEX, size, color, thick, cv2.LINE_AA)
-
-    # Titolo
-    _text(panel, "MODELLO", y + 18, size=0.7, color=(0, 200, 255), thick=2)
+    # Titolo MODELLO
+    _put_text(panel, "MODELLO", pad, y + 18, size=0.7,
+              color=(0, 200, 255), thick=2)
     y += 34
 
-    # Thumbnail modello
+    # Thumbnail
     th_h, th_w = template_bgr.shape[:2]
     max_tw = panel_width - 2 * pad
-    max_th = 150
+    max_th = 160
     sc = min(max_tw / th_w, max_th / th_h)
     tw = max(1, int(th_w * sc)); th = max(1, int(th_h * sc))
     thumb = cv2.resize(template_bgr, (tw, th), interpolation=cv2.INTER_AREA)
@@ -297,74 +297,123 @@ def build_info_panel(
     panel[y:y + th, tx:tx + tw] = thumb
     cv2.rectangle(panel, (tx - 1, y - 1), (tx + tw, y + th),
                   (90, 90, 90), 1, cv2.LINE_AA)
-    y += th + 12
+    y += th + 16
 
-    # Parametri
-    _text(panel, "PARAMETRI", y, size=0.55, color=(0, 200, 255), thick=2)
-    y += 20
-    for k, v in params.items():
-        _text(panel, f"{k}: {v}", y, size=0.42)
-        y += 16
-
-    y += 6
-    _text(panel, f"RISULTATI ({len(matches)})", y,
-          size=0.55, color=(0, 200, 255), thick=2)
-    y += 20
+    # Risultati
+    _put_text(panel, f"RISULTATI ({len(matches)})", pad, y,
+              size=0.6, color=(0, 200, 255), thick=2)
+    y += 22
     if matches:
         scores = [m.score for m in matches]
         scales = [m.scale for m in matches]
-        _text(panel, f"score: {min(scores):.2f}..{max(scores):.2f}", y,
-              size=0.42); y += 16
+        _put_text(panel, f"score: {min(scores):.2f}..{max(scores):.2f}",
+                  pad, y, size=0.42); y += 16
         if max(scales) != min(scales):
-            _text(panel, f"scale: {min(scales):.2f}..{max(scales):.2f}", y,
-                  size=0.42); y += 16
-
-        # Legenda numerata con colore per ogni match
-        max_rows = max(1, (panel_height - y - 120) // 16)
+            _put_text(panel, f"scale: {min(scales):.2f}..{max(scales):.2f}",
+                      pad, y, size=0.42); y += 16
+        y += 4
+        max_rows = max(1, (panel_height - y - 12) // 16)
         shown = matches[:max_rows]
         for i, m in enumerate(shown):
             color = _color_for(i)
-            # Pallino di colore
             cv2.circle(panel, (pad + 6, y - 4), 5, color, -1, cv2.LINE_AA)
             txt = (f"#{i+1} ({int(m.cx)},{int(m.cy)}) "
                    f"{m.angle_deg:.0f}d s={m.scale:.2f} {m.score:.3f}")
-            _text(panel, txt, y, size=0.40, x=pad + 18)
+            _put_text(panel, txt, pad + 18, y, size=0.40)
             y += 16
         if len(matches) > len(shown):
-            _text(panel, f"... +{len(matches) - len(shown)} altri",
-                  y, size=0.40, color=(150, 150, 150)); y += 16
-
-    # Hotkey in fondo
-    footer_y = panel_height - 92
-    _text(panel, "HOTKEY", footer_y, size=0.55, color=(0, 200, 255), thick=2)
-    fy = footer_y + 18
-    for line in [
-        "r  modifica parametri",
-        "o  nuovo ROI (stesso modello)",
-        "m  nuovo file modello",
-        "s  nuova scena",
-        "q / Esc  esci",
-    ]:
-        _text(panel, line, fy, size=0.40, color=(180, 180, 180))
-        fy += 14
+            _put_text(panel, f"... +{len(matches) - len(shown)} altri",
+                      pad, y, size=0.40, color=(150, 150, 150))
     return panel
 
 
-def compose_result(
-    scene_annotated: np.ndarray,
-    panel: np.ndarray,
+def build_right_panel(
+    params: dict,
+    panel_width: int = 320,
+    panel_height: int = 900,
 ) -> np.ndarray:
-    """Affianca pannello a sinistra + scena a destra, altezza uniforme."""
-    sH, sW = scene_annotated.shape[:2]
-    pH, pW = panel.shape[:2]
-    if pH != sH:
-        sc = sH / pH
-        new_pW = max(1, int(pW * sc))
-        panel = cv2.resize(panel, (new_pW, sH), interpolation=cv2.INTER_AREA)
-        pW = new_pW
-    out = np.zeros((sH, pW + sW, 3), dtype=np.uint8)
-    out[:, :pW] = panel
-    out[:, pW:] = scene_annotated
+    """Pannello destro: parametri correnti + hotkey."""
+    panel = np.full((panel_height, panel_width, 3), 28, dtype=np.uint8)
+    pad = 12
+    y = pad
+
+    _put_text(panel, "PARAMETRI", pad, y + 18, size=0.7,
+              color=(0, 200, 255), thick=2)
+    y += 36
+
+    # Tempi in alto, evidenziati
+    for k in ("train_time", "find_time", "num_variants"):
+        if k in params:
+            v = params[k]
+            _put_text(panel, f"{k}:", pad, y,
+                      size=0.45, color=(160, 220, 160))
+            _put_text(panel, str(v), pad + 140, y,
+                      size=0.45, color=(200, 255, 200), thick=2)
+            y += 18
+    y += 6
+
+    # Altri parametri
+    skip = {"train_time", "find_time", "num_variants"}
+    for k, v in params.items():
+        if k in skip:
+            continue
+        _put_text(panel, f"{k}:", pad, y, size=0.42, color=(180, 180, 180))
+        _put_text(panel, str(v), pad + 140, y, size=0.42,
+                  color=(220, 220, 220))
+        y += 16
+
+    # Hotkey in fondo
+    footer_y = panel_height - 110
+    _put_text(panel, "HOTKEY", pad, footer_y, size=0.6,
+              color=(0, 200, 255), thick=2)
+    fy = footer_y + 22
+    for line in [
+        "r  modifica parametri",
+        "o  nuovo ROI",
+        "m  nuovo modello",
+        "s  nuova scena",
+        "q / Esc  esci",
+    ]:
+        _put_text(panel, line, pad, fy, size=0.42, color=(200, 200, 200))
+        fy += 16
+    return panel
+
+
+def _fit_scene_center(
+    scene: np.ndarray, target_w: int, target_h: int,
+) -> np.ndarray:
+    """Scala scena a fit (target_w, target_h) mantenendo aspect; padding bg."""
+    h, w = scene.shape[:2]
+    sc = min(target_w / w, target_h / h)
+    new_w = max(1, int(w * sc)); new_h = max(1, int(h * sc))
+    resized = cv2.resize(scene, (new_w, new_h), interpolation=cv2.INTER_AREA)
+    out = np.full((target_h, target_w, 3), 20, dtype=np.uint8)
+    y0 = (target_h - new_h) // 2
+    x0 = (target_w - new_w) // 2
+    out[y0:y0 + new_h, x0:x0 + new_w] = resized
+    return out
+
+
+def compose_fixed_layout(
+    scene_annotated: np.ndarray,
+    left_panel: np.ndarray,
+    right_panel: np.ndarray,
+    window_w: int = 1600,
+    window_h: int = 900,
+) -> np.ndarray:
+    """Layout fisso: [left | scena fit-scaled | right]."""
+    lH, lW = left_panel.shape[:2]
+    rH, rW = right_panel.shape[:2]
+    # Altezza uniforme (pannelli dovrebbero essere già window_h)
+    if lH != window_h:
+        left_panel = cv2.resize(left_panel, (lW, window_h),
+                                interpolation=cv2.INTER_AREA)
+    if rH != window_h:
+        right_panel = cv2.resize(right_panel, (rW, window_h),
+                                 interpolation=cv2.INTER_AREA)
+    center_w = window_w - lW - rW
+    center = _fit_scene_center(scene_annotated, center_w, window_h)
+    out = np.concatenate([left_panel, center, right_panel], axis=1)
     return out
 
 
@@ -382,28 +431,38 @@ def show_results(
     matches: list[Match],
     template_bgr: np.ndarray | None = None,
     params: dict | None = None,
+    window_w: int = 1600,
+    window_h: int = 900,
 ) -> str:
-    """Visualizza risultati. Ritorna 'rematch' se l'utente preme 'r', altrimenti 'quit'."""
+    """Visualizza risultati in layout fisso [SX panel | scena scalata | DX panel].
+
+    Ritorna 'rematch'/'new_roi'/'new_model'/'new_scene'/'quit'.
+    """
     print(f"\n=== {len(matches)} match trovati ===")
     for i, m in enumerate(matches):
         print(f"  #{i+1}: cx={m.cx:.1f} cy={m.cy:.1f} "
               f"angle={m.angle_deg:.1f}d scale={m.scale:.2f} score={m.score:.3f}")
+
     template_gray = None
     if template_bgr is not None:
         template_gray = (template_bgr if template_bgr.ndim == 2
                          else cv2.cvtColor(template_bgr, cv2.COLOR_BGR2GRAY))
     annotated = draw_matches(scene, matches, template_gray=template_gray)
-    if template_bgr is not None and params is not None:
-        panel = build_info_panel(template_bgr, params, matches,
-                                 panel_height=annotated.shape[0])
-        composed = compose_result(annotated, panel)
+
+    if template_bgr is not None:
+        left = build_left_panel(template_bgr, matches, panel_height=window_h)
     else:
-        composed = annotated
-    disp = _fit_for_display(composed, max_side=1600)
-    cv2.namedWindow(WINDOW_RESULT, cv2.WINDOW_NORMAL)
-    cv2.resizeWindow(WINDOW_RESULT, min(disp.shape[1], 1600),
-                     min(disp.shape[0], 900))
-    cv2.imshow(WINDOW_RESULT, disp)
+        left = np.full((window_h, 300, 3), 28, dtype=np.uint8)
+    if params is not None:
+        right = build_right_panel(params, panel_height=window_h)
+    else:
+        right = np.full((window_h, 320, 3), 28, dtype=np.uint8)
+
+    composed = compose_fixed_layout(
+        annotated, left, right, window_w=window_w, window_h=window_h,
+    )
+    cv2.namedWindow(WINDOW_RESULT, cv2.WINDOW_AUTOSIZE)
+    cv2.imshow(WINDOW_RESULT, composed)
     print("\n[r] parametri  [o] nuovo ROI  [m] nuovo modello  [s] nuova scena  [q/Esc] chiudi")
     action = "quit"
     while True:

pm2d/line_matcher.py

@@ -26,6 +26,7 @@ della ROI (modello non-rettangolare).
 
 from __future__ import annotations
 
+import math
 import os
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
@@ -33,9 +34,12 @@ from dataclasses import dataclass
 import cv2
 import numpy as np
 
+_GOLDEN = (math.sqrt(5.0) - 1.0) / 2.0  # ≈ 0.618
+
 from pm2d._jit_kernels import (
     score_by_shift as _jit_score_by_shift,
     score_bitmap as _jit_score_bitmap,
+    score_bitmap_rescored as _jit_score_bitmap_rescored,
     popcount_density as _jit_popcount,
     HAS_NUMBA,
 )
@@ -133,6 +137,8 @@ class LineShapeMatcher:
         self.variants: list[_Variant] = []
         self.template_size: tuple[int, int] = (0, 0)
         self.template_gray: np.ndarray | None = None
+        # Maschera usata in training (propagata al refine per coerenza).
+        self._train_mask: np.ndarray | None = None
 
     # --- Helpers -------------------------------------------------------
 
@@ -230,6 +236,7 @@ class LineShapeMatcher:
             mask_full = np.full((h, w), 255, dtype=np.uint8)
         else:
             mask_full = (mask > 0).astype(np.uint8) * 255
+        self._train_mask = mask_full.copy()
 
         self.variants.clear()
         for s in self._scale_list():
@@ -333,18 +340,55 @@ class LineShapeMatcher:
         return _jit_score_by_shift(resp, dx, dy, bins, bin_has_data)
 
     @staticmethod
-    def _subpixel_peak(acc: np.ndarray, x: int, y: int) -> tuple[float, float]:
-        """Fit parabolico 2D attorno al picco per offset subpixel (±0.5 px)."""
+    def _subpixel_peak(
+        acc: np.ndarray, x: int, y: int, plateau_radius: int = 10,
+    ) -> tuple[float, float]:
+        """Posizione sub-pixel del picco.
+
+        1. Plateau saturo → centroide pesato del plateau (peso = score).
+        2. Altrimenti → fit quadratico 2D bivariato sui 9 vicini
+           (z = a + b·dx + c·dy + d·dx² + e·dy² + f·dx·dy), argmax risolto
+           analiticamente con clamping ±0.5 px.
+        """
         H, W = acc.shape
+        val = float(acc[y, x])
+        # Plateau detection: valori >= val - 0.01 entro raggio limitato
+        y0 = max(0, y - plateau_radius); y1 = min(H, y + plateau_radius + 1)
+        x0 = max(0, x - plateau_radius); x1 = min(W, x + plateau_radius + 1)
+        patch = acc[y0:y1, x0:x1]
+        plateau = patch >= val - 0.01
+        if plateau.sum() > 1:
+            # Centroide pesato per (score - (max-0.01))² per enfatizzare i top
+            weights = np.where(plateau, patch - (val - 0.01), 0.0).astype(np.float64)
+            weights = weights * weights
+            total = weights.sum()
+            if total > 1e-9:
+                ys_idx, xs_idx = np.indices(patch.shape)
+                cx_w = (xs_idx * weights).sum() / total
+                cy_w = (ys_idx * weights).sum() / total
+                return float(x0 + cx_w), float(y0 + cy_w)
+            ys_m, xs_m = np.where(plateau)
+            return float(x0 + xs_m.mean()), float(y0 + ys_m.mean())
+        # Fit quadratico 2D bivariato su 3x3 intorno
         if x <= 0 or x >= W - 1 or y <= 0 or y >= H - 1:
             return float(x), float(y)
-        c = acc[y, x]
-        dx2 = acc[y, x + 1] - 2 * c + acc[y, x - 1]
-        dy2 = acc[y + 1, x] - 2 * c + acc[y - 1, x]
-        dx1 = (acc[y, x + 1] - acc[y, x - 1]) / 2.0
-        dy1 = (acc[y + 1, x] - acc[y - 1, x]) / 2.0
-        ox = -dx1 / dx2 if abs(dx2) > 1e-6 else 0.0
-        oy = -dy1 / dy2 if abs(dy2) > 1e-6 else 0.0
+        # Stencil 3x3: Z[i, j] con i,j ∈ {-1, 0, +1}
+        Z = acc[y - 1:y + 2, x - 1:x + 2].astype(np.float64)
+        # Coefficienti da finite differences
+        b_c = (Z[1, 2] - Z[1, 0]) / 2.0
+        c_c = (Z[2, 1] - Z[0, 1]) / 2.0
+        d_c = (Z[1, 2] + Z[1, 0] - 2.0 * Z[1, 1]) / 2.0
+        e_c = (Z[2, 1] + Z[0, 1] - 2.0 * Z[1, 1]) / 2.0
+        f_c = (Z[2, 2] - Z[0, 2] - Z[2, 0] + Z[0, 0]) / 4.0
+        # Max: risolve [2d f; f 2e][dx;dy] = [-b;-c]
+        det = 4.0 * d_c * e_c - f_c * f_c
+        if abs(det) > 1e-9:
+            ox = (-2.0 * e_c * b_c + f_c * c_c) / det
+            oy = (-2.0 * d_c * c_c + f_c * b_c) / det
+        else:
+            # Fallback separabile
+            ox = -b_c / (2.0 * d_c) if abs(d_c) > 1e-6 else 0.0
+            oy = -c_c / (2.0 * e_c) if abs(e_c) > 1e-6 else 0.0
         ox = float(np.clip(ox, -0.5, 0.5))
         oy = float(np.clip(oy, -0.5, 0.5))
         return x + ox, y + oy
@@ -359,6 +403,7 @@ class LineShapeMatcher:
         mask_full: np.ndarray,
         angle_fine_step: float = 0.5,
         search_radius: float | None = None,
+        original_score: float | None = None,
     ) -> tuple[float, float, float, float]:
         """Ricerca angolare fine (sub-step) attorno al match grezzo.
 
@@ -366,11 +411,11 @@ class LineShapeMatcher:
         l'angolo con score massimo (parabolic fit sulle 3 score centrali).
         Ritorna (angle_refined, score, cx_refined, cy_refined).
         """
+        # Se il match grezzo è già quasi perfetto, NON refinare
+        if original_score is not None and original_score >= 0.99:
+            return (angle_deg, original_score, cx, cy)
         if search_radius is None:
             search_radius = self.angle_step_deg / 2.0
-        offsets = np.linspace(-search_radius, search_radius, 5)
-        best = (angle_deg, -1.0, cx, cy)
-        scores_by_off: dict[float, float] = {}
 
         h, w = template_gray.shape
         sw = max(16, int(round(w * scale)))
@@ -386,10 +431,10 @@ class LineShapeMatcher:
         center = (diag / 2.0, diag / 2.0)
 
         H, W = spread0.shape
-        # Ricerca locale posizione con margine ±2 px sulla (cx, cy)
         margin = 3
 
-        for off in offsets:
+        def _score_at_angle(off: float) -> tuple[float, float, float]:
+            """Ritorna (score, best_cx, best_cy) per angolo = angle_deg + off."""
             ang = angle_deg + off
             M = cv2.getRotationMatrix2D(center, ang, 1.0)
             gray_r = cv2.warpAffine(gray_p, M, (diag, diag),
@@ -400,22 +445,20 @@ class LineShapeMatcher:
             mag, bins = self._gradient(gray_r)
             fx, fy, fb = self._extract_features(mag, bins, mask_r)
             if len(fx) < 8:
-                scores_by_off[float(off)] = 0.0
-                continue
+                return (0.0, cx, cy)
             dx = (fx - center[0]).astype(np.int32)
             dy = (fy - center[1]).astype(np.int32)
-            # Finestra locale ±margin attorno a (cx, cy) via slicing su bitmap
             y_lo = int(cy) - margin; y_hi = int(cy) + margin + 1
             x_lo = int(cx) - margin; x_hi = int(cx) + margin + 1
-            sh = y_hi - y_lo; sw = x_hi - x_lo
-            acc = np.zeros((sh, sw), dtype=np.float32)
+            sh_w = y_hi - y_lo; sw_w = x_hi - x_lo
+            acc = np.zeros((sh_w, sw_w), dtype=np.float32)
             for i in range(len(dx)):
                 ddx = int(dx[i]); ddy = int(dy[i]); b = int(fb[i])
                 bit = np.uint8(1 << b)
                 sy0 = y_lo + ddy; sy1 = y_hi + ddy
                 sx0 = x_lo + ddx; sx1 = x_hi + ddx
-                a_y0 = max(0, -sy0); a_y1 = sh - max(0, sy1 - H)
-                a_x0 = max(0, -sx0); a_x1 = sw - max(0, sx1 - W)
+                a_y0 = max(0, -sy0); a_y1 = sh_w - max(0, sy1 - H)
+                a_x0 = max(0, -sx0); a_x1 = sw_w - max(0, sx1 - W)
                 s_y0 = max(0, sy0); s_y1 = min(H, sy1)
                 s_x0 = max(0, sx0); s_x1 = min(W, sx1)
                 if s_y1 > s_y0 and s_x1 > s_x0:
@@ -425,31 +468,39 @@ class LineShapeMatcher:
                     ).astype(np.float32)
             acc /= len(dx)
             _, max_val, _, max_loc = cv2.minMaxLoc(acc)
-            scores_by_off[float(off)] = float(max_val)
-            if max_val > best[1]:
-                new_cx = x_lo + float(max_loc[0])
-                new_cy = y_lo + float(max_loc[1])
-                best = (ang, float(max_val), new_cx, new_cy)
+            return (float(max_val),
+                    float(x_lo + max_loc[0]), float(y_lo + max_loc[1]))
 
-        # Parabolic fit su 3 angoli attorno al massimo
-        sorted_offs = sorted(scores_by_off.keys())
-        best_off = best[0] - angle_deg
-        try:
-            i = sorted_offs.index(
-                min(sorted_offs, key=lambda x: abs(x - best_off))
-            )
-            if 0 < i < len(sorted_offs) - 1:
-                s0 = scores_by_off[sorted_offs[i - 1]]
-                s1 = scores_by_off[sorted_offs[i]]
-                s2 = scores_by_off[sorted_offs[i + 1]]
-                denom = (s0 - 2 * s1 + s2)
-                if abs(denom) > 1e-6:
-                    delta = 0.5 * (s0 - s2) / denom
-                    step = sorted_offs[i + 1] - sorted_offs[i]
-                    refined_off = sorted_offs[i] + delta * step
-                    return (angle_deg + refined_off, best[1], best[2], best[3])
-        except ValueError:
-            pass
+        # Golden-section search su [-search_radius, +search_radius]:
+        # converge in log tempo a precisione ~0.1°, ~8 valutazioni vs 5
+        # ma centrate su picco reale (non sample equispaziati).
+        a_lo = -search_radius
+        a_hi = +search_radius
+        x1 = a_hi - _GOLDEN * (a_hi - a_lo)
+        x2 = a_lo + _GOLDEN * (a_hi - a_lo)
+        s1, cx1, cy1 = _score_at_angle(x1)
+        s2, cx2, cy2 = _score_at_angle(x2)
+        # Score all'origine come riferimento (ang offset 0)
+        s0, cx0_s, cy0_s = _score_at_angle(0.0)
+        best = (angle_deg, s0, cx0_s, cy0_s)
+        tol = 0.1  # gradi
+        for _ in range(8):
+            if s1 > best[1]:
+                best = (angle_deg + x1, s1, cx1, cy1)
+            if s2 > best[1]:
+                best = (angle_deg + x2, s2, cx2, cy2)
+            if abs(a_hi - a_lo) < tol:
+                break
+            if s1 > s2:
+                a_hi = x2
+                x2 = x1; s2 = s1; cx2 = cx1; cy2 = cy1
+                x1 = a_hi - _GOLDEN * (a_hi - a_lo)
+                s1, cx1, cy1 = _score_at_angle(x1)
+            else:
+                a_lo = x1
+                x1 = x2; s1 = s2; cx1 = cx2; cy1 = cy2
+                x2 = a_lo + _GOLDEN * (a_hi - a_lo)
+                s2, cx2, cy2 = _score_at_angle(x2)
         return best
 
     def _verify_ncc(
@@ -458,6 +509,10 @@ class LineShapeMatcher:
     ) -> float:
         """NCC tra template warpato alla pose e scena sottostante.
 
+        Lavora su un **crop locale** della scena di lato = diagonale del
+        template ruotato+scalato, non sull'intera scena. Su scene grandi
+        (1920×1080) taglia drasticamente il costo del warp per ogni match.
+
         Ritorna score [-1, 1]. Usato come filtro anti-falso-positivo:
         il matcher linemod può dare score alto su texture generiche ma
         sovrapponendo il template gray i pixel non corrispondono.
@@ -468,23 +523,40 @@ class LineShapeMatcher:
         h, w = t.shape
         cx_t = (w - 1) / 2.0
         cy_t = (h - 1) / 2.0
-        M = cv2.getRotationMatrix2D((cx_t, cy_t), angle_deg, scale)
-        M[0, 2] += cx - cx_t
-        M[1, 2] += cy - cy_t
+
+        # Bounding box del template ruotato/scalato attorno a (cx, cy)
+        diag = int(np.ceil(np.hypot(w, h) * scale)) + 8
         H, W = scene_gray.shape
+        x0 = int(round(cx)) - diag // 2
+        y0 = int(round(cy)) - diag // 2
+        cx0 = max(0, x0); cy0 = max(0, y0)
+        cx1 = min(W, x0 + diag); cy1 = min(H, y0 + diag)
+        if cx1 - cx0 < 10 or cy1 - cy0 < 10:
+            return 0.0
+        scn_crop = scene_gray[cy0:cy1, cx0:cx1]
+        ch, cw = scn_crop.shape
+
+        M = cv2.getRotationMatrix2D((cx_t, cy_t), angle_deg, scale)
+        # Porta il centro del template a (cx - cx0, cy - cy0) del crop
+        M[0, 2] += (cx - cx0) - cx_t
+        M[1, 2] += (cy - cy0) - cy_t
         warped = cv2.warpAffine(
-            t, M, (W, H),
+            t, M, (cw, ch),
             flags=cv2.INTER_LINEAR, borderValue=0,
         )
-        mask = cv2.warpAffine(
-            np.full_like(t, 255), M, (W, H),
+        if self._train_mask is not None:
+            mask_src = self._train_mask
+        else:
+            mask_src = np.full_like(t, 255)
+        mask_w = cv2.warpAffine(
+            mask_src, M, (cw, ch),
             flags=cv2.INTER_NEAREST, borderValue=0,
         )
-        valid = mask > 0
+        valid = mask_w > 0
         if valid.sum() < 20:
             return 0.0
         tpl = warped[valid].astype(np.float32)
-        scn = scene_gray[valid].astype(np.float32)
+        scn = scn_crop[valid].astype(np.float32)
         tm = tpl - tpl.mean()
         sm = scn - scn.mean()
         denom = np.sqrt((tm * tm).sum() * (sm * sm).sum()) + 1e-9
@@ -500,7 +572,17 @@ class LineShapeMatcher:
         subpixel: bool = True,
         verify_ncc: bool = True,
         verify_threshold: float = 0.4,
+        coarse_angle_factor: int = 2,
+        coarse_stride: int = 1,
+        scale_penalty: float = 0.0,
     ) -> list[Match]:
+        """
+        scale_penalty: se > 0, riduce lo score per match a scala diversa da 1.0:
+          score_final = score_shape * max(0, 1 - scale_penalty * |scale - 1|)
+        Utile se l'operatore vuole che match "identico al template anche per
+        dimensione" abbia score più alto di match "stessa forma, dimensione
+        diversa". scale_penalty=0 (default) = comportamento shape puro.
+        """
         if not self.variants:
             raise RuntimeError("Matcher non addestrato: chiamare train() prima.")
 
@@ -541,27 +623,79 @@ class LineShapeMatcher:
         def _rescore(score: np.ndarray, bg: np.ndarray) -> np.ndarray:
             return np.maximum(0.0, (score - bg) / (1.0 - bg + 1e-6))
 
-        # Pruning varianti via top-level (parallelizzato)
+        # Coarse-to-fine angolare:
+        # 1) Raggruppa varianti per scala, ordina per angolo
+        # 2) Top-level: valuta solo 1 ogni coarse_angle_factor varianti
+        # 3) Espandi ai vicini nel full-res
+        variants_by_scale: dict[float, list[int]] = {}
+        for vi, var in enumerate(self.variants):
+            variants_by_scale.setdefault(var.scale, []).append(vi)
+
+        coarse_idx_list: list[int] = []  # varianti da valutare al top
+        neighbor_map: dict[int, list[int]] = {}  # vi_coarse -> indici vicini
+        cf = max(1, coarse_angle_factor)
+        for scale_key, vi_list in variants_by_scale.items():
+            vi_sorted = sorted(vi_list, key=lambda i: self.variants[i].angle_deg)
+            n = len(vi_sorted)
+            for i in range(0, n, cf):
+                vi_c = vi_sorted[i]
+                coarse_idx_list.append(vi_c)
+                # Vicini: ±cf/2 attorno a i (stessa scala)
+                half = cf // 2
+                start = max(0, i - half)
+                end = min(n, i + half + 1)
+                neighbor_map[vi_c] = vi_sorted[start:end]
+
+        # Pruning varianti via top-level (parallelizzato) - solo coarse.
+        # coarse_stride > 1: valuta solo 1 pixel ogni stride, ~stride² speed-up.
+        cs = max(1, int(coarse_stride))
+
         def _top_score(vi: int) -> tuple[int, float]:
             var = self.variants[vi]
             lvl = var.levels[min(top, len(var.levels) - 1)]
-            score = _jit_score_bitmap(
+            score = _jit_score_bitmap_rescored(
                 spread_top, lvl.dx, lvl.dy, lvl.bin, bit_active_top,
+                bg_cache_top[var.scale], stride=cs,
             )
-            score = _rescore(score, bg_cache_top[var.scale])
             return vi, float(score.max()) if score.size else -1.0
 
-        kept_variants: list[tuple[int, float]] = []
-        if self.n_threads > 1:
+        kept_coarse: list[tuple[int, float]] = []
+        all_top_scores: list[tuple[int, float]] = []
+        if self.n_threads > 1 and len(coarse_idx_list) > 1:
             with ThreadPoolExecutor(max_workers=self.n_threads) as ex:
-                for vi, best in ex.map(_top_score, range(len(self.variants))):
+                for vi, best in ex.map(_top_score, coarse_idx_list):
+                    all_top_scores.append((vi, best))
                     if best >= top_thresh:
-                        kept_variants.append((vi, best))
+                        kept_coarse.append((vi, best))
         else:
-            for vi in range(len(self.variants)):
+            for vi in coarse_idx_list:
                 vi2, best = _top_score(vi)
+                all_top_scores.append((vi2, best))
                 if best >= top_thresh:
-                    kept_variants.append((vi2, best))
+                    kept_coarse.append((vi2, best))
+
+        # Fallback adattivo: se il rescore background ha abbattuto tutti
+        # gli score sotto top_thresh (scene texturate pesanti), ripesca
+        # le varianti migliori al top level per dare comunque una chance
+        # alla fase full-res invece di ritornare 0 match.
+        if not kept_coarse and all_top_scores:
+            all_top_scores.sort(key=lambda t: -t[1])
+            n_keep = max(4, len(all_top_scores) // 10)
+            # Limita a varianti con score top > 0 (non completamente a zero)
+            kept_coarse = [(vi, s) for vi, s in all_top_scores[:n_keep] if s > 0]
+
+        # Espandi ogni coarse promosso con i suoi vicini (stessa scala,
+        # angoli intermedi non valutati al top)
+        expanded: set[int] = set()
+        score_by_vi: dict[int, float] = {}
+        for vi_c, s_top in kept_coarse:
+            for vi_n in neighbor_map.get(vi_c, [vi_c]):
+                expanded.add(vi_n)
+                # Usa lo score del coarse come stima per il sort successivo
+                score_by_vi[vi_n] = max(score_by_vi.get(vi_n, 0.0), s_top)
+        kept_variants: list[tuple[int, float]] = [
+            (vi, score_by_vi[vi]) for vi in expanded
+        ]
 
         if not kept_variants:
             return []
@@ -586,10 +720,10 @@ class LineShapeMatcher:
         def _full_score(vi: int) -> tuple[int, np.ndarray]:
             var = self.variants[vi]
             lvl0 = var.levels[0]
-            score = _jit_score_bitmap(
+            score = _jit_score_bitmap_rescored(
                 spread0, lvl0.dx, lvl0.dy, lvl0.bin, bit_active_full,
+                bg_cache_full[var.scale],
             )
-            score = _rescore(score, bg_cache_full[var.scale])
             return vi, score
 
         candidates_per_var: list[tuple[int, np.ndarray]] = []
@@ -601,14 +735,24 @@ class LineShapeMatcher:
         else:
             results = [_full_score(vi) for vi in var_indices]
 
+        def _scale_factor(s: float) -> float:
+            """Penalità moltiplicativa per scala diversa da 1.0."""
+            if scale_penalty > 0.0 and s != 1.0:
+                return max(0.0, 1.0 - scale_penalty * abs(s - 1.0))
+            return 1.0
+
         for vi, score in results:
-            ys, xs = np.where(score >= min_score)
+            pen = _scale_factor(self.variants[vi].scale)
+            # Ordinare/sogliare su score penalizzato: un match a scala 1.5 con
+            # score 0.8 e penalty=0.3 effettivamente vale 0.56, non 0.8.
+            score_for_sort = score if pen == 1.0 else score * pen
+            ys, xs = np.where(score_for_sort >= min_score)
             if len(ys) == 0:
                 continue
-            vals = score[ys, xs]
+            vals = score_for_sort[ys, xs]
             K = min(len(vals), max_matches * 5)
             ord_idx = np.argpartition(-vals, K - 1)[:K]
-            candidates_per_var.append((vi, score))
+            candidates_per_var.append((vi, score))  # score_map originale
             for i in ord_idx:
                 raw.append((float(vals[i]), int(xs[i]), int(ys[i]), vi))
 
@@ -618,32 +762,43 @@ class LineShapeMatcher:
         score_maps = dict(candidates_per_var)
 
         # NMS + subpixel + refinement angolare
-        # Mask template per refinement (non disponibile qui: usa full)
+        # Usa mask salvata in train() per coerenza (se ROI poligonale).
         h, w = self.template_gray.shape if self.template_gray is not None else (0, 0)
-        mask_full = np.full((h, w), 255, dtype=np.uint8)
+        mask_full = (
+            self._train_mask if self._train_mask is not None
+            else np.full((h, w), 255, dtype=np.uint8)
+        )
+        # Plateau radius adattivo al template (evita plateau troppo ampi su
+        # template piccoli: 8% del lato minimo, clampato [3, 10]).
+        plateau_r = max(3, min(10, int(min(self.template_size) * 0.08)))
 
-        # Pre-NMS rapido su raw (solo subpixel, no refine/verify): riduce
-        # i candidati a ~max_matches*3 prima di operazioni costose (refine,
-        # verify) che erano chiamate per ogni raw causando lentezze 100x.
+        # Pre-NMS rapido su raw con coordinate intere (nms_radius ≥ 8,
+        # la precisione sub-pixel non cambia la decisione di reject).
+        # Subpixel viene calcolato DOPO il pre-NMS solo sui ~pre_cap
+        # preliminary sopravvissuti: prima era chiamato su ogni raw (~58k
+        # chiamate su clip_preciso) anche se la maggior parte veniva poi
+        # scartata dalla NMS, sprecando la parte più costosa del loop.
         r2 = nms_radius * nms_radius
-        preliminary: list[tuple[float, float, float, int]] = []
         pre_cap = max(max_matches * 3, max_matches + 10)
+        preliminary_int: list[tuple[float, int, int, int]] = []
         for score, xi, yi, vi in raw:
-            if subpixel and vi in score_maps:
-                cx_f, cy_f = self._subpixel_peak(score_maps[vi], xi, yi)
-            else:
-                cx_f, cy_f = float(xi), float(yi)
-            if any((k[1] - cx_f) ** 2 + (k[2] - cy_f) ** 2 < r2
-                   for k in preliminary):
+            if any((k[1] - xi) ** 2 + (k[2] - yi) ** 2 < r2
+                   for k in preliminary_int):
                 continue
-            preliminary.append((score, cx_f, cy_f, vi))
-            if len(preliminary) >= pre_cap:
+            preliminary_int.append((score, xi, yi, vi))
+            if len(preliminary_int) >= pre_cap:
                 break
 
-        # Ora refine + verify solo sui candidati pre-NMS
+        # Subpixel + refine + verify solo sui candidati pre-NMS (max pre_cap)
         kept: list[Match] = []
         tw, th = self.template_size
-        for score, cx_f, cy_f, vi in preliminary:
+        for score, xi, yi, vi in preliminary_int:
+            if subpixel and vi in score_maps:
+                cx_f, cy_f = self._subpixel_peak(
+                    score_maps[vi], xi, yi, plateau_radius=plateau_r,
+                )
+            else:
+                cx_f, cy_f = float(xi), float(yi)
             var = self.variants[vi]
             ang_f = var.angle_deg
             score_f = score
@@ -652,6 +807,7 @@ class LineShapeMatcher:
                     spread0, bit_active_full, self.template_gray, cx_f, cy_f,
                     var.angle_deg, var.scale, mask_full,
                     search_radius=self.angle_step_deg / 2.0,
+                    original_score=score,
                 )
             if verify_ncc:
                 ncc = self._verify_ncc(gray0, cx_f, cy_f, ang_f, var.scale)
@@ -661,6 +817,11 @@ class LineShapeMatcher:
             poly = _oriented_bbox_polygon(
                 cx_f, cy_f, tw * var.scale, th * var.scale, ang_f,
             )
+            # Penalità scala opzionale: score degrada con distanza da 1.0
+            if scale_penalty > 0.0 and var.scale != 1.0:
+                score_f = float(score_f) * max(
+                    0.0, 1.0 - scale_penalty * abs(var.scale - 1.0)
+                )
             kept.append(Match(
                 cx=cx_f, cy=cy_f,
                 angle_deg=ang_f,

pm2d/web/server.py

@@ -0,0 +1,589 @@
+"""FastAPI webapp standalone per PM2D.
+
+Endpoint:
+  GET  /                    → HTML UI
+  POST /upload              → upload immagine (multipart)
+  POST /match               → JSON params + ids → results
+  GET  /image/{id}/raw      → PNG originale
+  GET  /image/{id}/annotated → PNG con overlay match
+"""
+from __future__ import annotations
+
+import hashlib
+import os
+import tempfile
+import time
+import uuid
+from collections import OrderedDict
+from pathlib import Path
+
+import cv2
+import numpy as np
+from fastapi import FastAPI, File, HTTPException, UploadFile
+from fastapi.responses import HTMLResponse, Response
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+
+
+def _load_env(root: Path) -> None:
+    """Legge .env in root e popola os.environ (no override se già set)."""
+    f = root / ".env"
+    if not f.exists():
+        return
+    for line in f.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        k, v = line.split("=", 1)
+        k = k.strip(); v = v.strip().strip('"').strip("'")
+        os.environ.setdefault(k, v)
+
+
+# Root progetto (parent di pm2d/)
+PROJECT_ROOT = Path(__file__).resolve().parents[2]
+_load_env(PROJECT_ROOT)
+
+_images_dir_raw = os.environ.get("IMAGES_DIR", "Test")
+IMAGES_DIR = Path(_images_dir_raw)
+if not IMAGES_DIR.is_absolute():
+    IMAGES_DIR = PROJECT_ROOT / IMAGES_DIR
+
+from pm2d.line_matcher import LineShapeMatcher, Match
+from pm2d.auto_tune import auto_tune
+
+
+WEB_DIR = Path(__file__).parent
+STATIC_DIR = WEB_DIR / "static"
+STATIC_DIR.mkdir(exist_ok=True)
+
+# Persistenza immagini su disco (sopravvive a restart server)
+CACHE_DIR = Path(tempfile.gettempdir()) / "pm2d_cache"
+CACHE_DIR.mkdir(exist_ok=True)
+
+# Cache in-memory (soft, ricaricata da disco se mancante)
+_IMG_CACHE: dict[str, np.ndarray] = {}
+
+# Cache matcher addestrati: (roi_hash, params_hash) -> LineShapeMatcher
+# LRU con capacità limitata
+_MATCHER_CACHE: OrderedDict = OrderedDict()
+_MATCHER_CACHE_SIZE = 8
+
+
+def _matcher_cache_key(roi: np.ndarray, tech: dict) -> str:
+    h = hashlib.md5()
+    h.update(roi.tobytes())
+    # Solo parametri che influenzano il training
+    relevant = ("num_features", "weak_grad", "strong_grad",
+                "angle_min", "angle_max", "angle_step",
+                "scale_min", "scale_max", "scale_step",
+                "spread_radius", "pyramid_levels")
+    for k in relevant:
+        h.update(f"{k}={tech.get(k)}".encode())
+    h.update(f"shape={roi.shape}".encode())
+    return h.hexdigest()
+
+
+def _cache_get_matcher(key: str):
+    m = _MATCHER_CACHE.get(key)
+    if m is not None:
+        _MATCHER_CACHE.move_to_end(key)  # LRU touch
+    return m
+
+
+def _cache_put_matcher(key: str, matcher) -> None:
+    _MATCHER_CACHE[key] = matcher
+    _MATCHER_CACHE.move_to_end(key)
+    while len(_MATCHER_CACHE) > _MATCHER_CACHE_SIZE:
+        _MATCHER_CACHE.popitem(last=False)
+
+
+def _store_image(img: np.ndarray) -> str:
+    iid = uuid.uuid4().hex[:12]
+    cv2.imwrite(str(CACHE_DIR / f"{iid}.png"), img)
+    _IMG_CACHE[iid] = img
+    return iid
+
+
+def _load_image(iid: str) -> np.ndarray | None:
+    cached = _IMG_CACHE.get(iid)
+    if cached is not None:
+        return cached
+    p = CACHE_DIR / f"{iid}.png"
+    if not p.exists():
+        return None
+    img = cv2.imread(str(p))
+    if img is not None:
+        _IMG_CACHE[iid] = img
+    return img
+
+app = FastAPI(title="PM2D Webapp", version="1.0.0")
+
+
+def _encode_png(img: np.ndarray) -> bytes:
+    ok, buf = cv2.imencode(".png", img)
+    if not ok:
+        raise RuntimeError("PNG encode failed")
+    return buf.tobytes()
+
+
+def _draw_matches(scene: np.ndarray, matches: list[Match],
+                   template_gray: np.ndarray | None) -> np.ndarray:
+    out = scene.copy()
+    H, W = scene.shape[:2]
+    palette = [
+        (0, 255, 0), (0, 200, 255), (255, 100, 100), (255, 200, 0),
+        (200, 0, 255), (100, 255, 200), (255, 0, 0), (0, 255, 255),
+    ]
+    for i, m in enumerate(matches):
+        color = palette[i % len(palette)]
+        if template_gray is not None:
+            t = template_gray
+            th, tw = t.shape
+            edge = cv2.Canny(t, 50, 150)
+            cx_t = (tw - 1) / 2.0; cy_t = (th - 1) / 2.0
+            M = cv2.getRotationMatrix2D((cx_t, cy_t), m.angle_deg, m.scale)
+            M[0, 2] += m.cx - cx_t
+            M[1, 2] += m.cy - cy_t
+            warped = cv2.warpAffine(edge, M, (W, H),
+                                     flags=cv2.INTER_NEAREST, borderValue=0)
+            mask = warped > 0
+            if mask.any():
+                overlay = np.zeros_like(out)
+                overlay[mask] = color
+                out[mask] = (0.3 * out[mask] + 0.7 * overlay[mask]).astype(np.uint8)
+        poly = m.bbox_poly.astype(np.int32).reshape(-1, 1, 2)
+        cv2.polylines(out, [poly], True, color, 2, cv2.LINE_AA)
+        p0 = tuple(m.bbox_poly[0].astype(int))
+        p1 = tuple(m.bbox_poly[1].astype(int))
+        cv2.line(out, p0, p1, color, 4, cv2.LINE_AA)
+        cx, cy = int(round(m.cx)), int(round(m.cy))
+        cv2.drawMarker(out, (cx, cy), color, cv2.MARKER_CROSS, 22, 2, cv2.LINE_AA)
+        L = int(np.linalg.norm(m.bbox_poly[1] - m.bbox_poly[0])) // 2
+        a = np.deg2rad(m.angle_deg)
+        cv2.arrowedLine(out, (cx, cy),
+                        (int(cx + L * np.cos(a)), int(cy - L * np.sin(a))),
+                        color, 2, cv2.LINE_AA, tipLength=0.2)
+        label = f"#{i+1} {m.angle_deg:.0f}d s={m.scale:.2f} {m.score:.2f}"
+        cv2.putText(out, label, (cx + 8, cy - 8),
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2, cv2.LINE_AA)
+    return out
+
+
+# ---------------- Models ----------------
+
+class UploadResp(BaseModel):
+    id: str
+    width: int
+    height: int
+
+
+class MatchParams(BaseModel):
+    model_id: str
+    scene_id: str
+    roi: list[int]  # [x, y, w, h] nell'immagine modello
+    angle_min: float = 0.0
+    angle_max: float = 360.0
+    angle_step: float = 5.0
+    scale_min: float = 1.0
+    scale_max: float = 1.0
+    scale_step: float = 0.1
+    min_score: float = 0.55
+    max_matches: int = 25
+    nms_radius: int = 0
+    num_features: int = 96
+    weak_grad: float = 30.0
+    strong_grad: float = 60.0
+    spread_radius: int = 5
+    pyramid_levels: int = 3
+    verify_threshold: float = 0.4
+
+
+class MatchResult(BaseModel):
+    cx: float
+    cy: float
+    angle_deg: float
+    scale: float
+    score: float
+    bbox_poly: list[list[float]]
+
+
+class MatchResp(BaseModel):
+    matches: list[MatchResult]
+    train_time: float
+    find_time: float
+    num_variants: int
+    annotated_id: str
+
+
+class TuneParams(BaseModel):
+    model_id: str
+    roi: list[int]
+
+
+# ---------- User-facing (simple) params ----------
+
+SYMMETRY_TO_ANGLE_MAX = {
+    "invariante": 0.0,   # oggetto simmetrico a rotazione totale (cerchi): 1 variante
+    "nessuna": 360.0,
+    "bilaterale": 180.0,
+    "rot_3": 120.0,
+    "rot_4": 90.0,
+    "rot_6": 60.0,
+    "rot_8": 45.0,
+}
+
+SCALE_PRESETS = {
+    "fissa":  (1.0, 1.0, 0.1),
+    "mini":   (0.9, 1.1, 0.05),    # ±10%
+    "medio":  (0.75, 1.25, 0.05),  # ±25%
+    "max":    (0.5, 1.5, 0.05),    # ±50%
+}
+
+PRECISION_ANGLE_STEP = {
+    "veloce": 10.0,
+    "normale": 5.0,
+    "preciso": 2.0,
+}
+
+# "Filtro falsi positivi" = mapping semantico del verify NCC threshold.
+# Un operatore sceglie il livello di rigore, non un numero astratto.
+FILTRO_FP_MAP = {
+    "off":      0.0,   # disabilitato: mantieni tutti i match shape-based
+    "leggero":  0.20,  # tollera variazioni intensità/illuminazione forti
+    "medio":    0.35,  # default bilanciato (consigliato)
+    "forte":    0.50,  # scarta match con intensità molto diversa dal template
+}
+
+
+class SimpleMatchParams(BaseModel):
+    model_id: str
+    scene_id: str
+    roi: list[int]
+    tipo: str = "intero"              # "intero" | "parziale"
+    simmetria: str = "nessuna"        # chiave SYMMETRY_TO_ANGLE_MAX
+    scala: str = "fissa"              # chiave SCALE_PRESETS
+    precisione: str = "normale"       # chiave PRECISION_ANGLE_STEP
+    filtro_fp: str = "medio"          # chiave FILTRO_FP_MAP
+    penalita_scala: float = 0.0       # 0 = score shape invariante, >0 = penalizza scala != 1
+    min_score: float = 0.65
+    max_matches: int = 25
+
+
+def _simple_to_technical(
+    p: SimpleMatchParams, roi_img: np.ndarray,
+) -> dict:
+    """Converti parametri user-facing → tecnici usando analisi della ROI."""
+    from pm2d.auto_tune import auto_tune as _auto
+
+    tune = _auto(roi_img)
+    h, w = roi_img.shape[:2]
+    min_side = min(h, w)
+
+    # Feature count: parziale = meno feature (area minore)
+    nf = tune["num_features"]
+    if p.tipo == "parziale":
+        nf = max(32, int(nf * 0.6))
+
+    # Piramide derivata da dimensione ROI
+    if min_side < 60:
+        pyr = 1
+    elif min_side < 150:
+        pyr = 2
+    elif min_side < 400:
+        pyr = 3
+    else:
+        pyr = 4
+
+    # Spread radius ~2-3% del lato minimo
+    spread = max(3, min(10, int(round(min_side * 0.03))))
+
+    angle_max = SYMMETRY_TO_ANGLE_MAX.get(p.simmetria, 360.0)
+    smin, smax, sstep = SCALE_PRESETS.get(p.scala, (1.0, 1.0, 0.1))
+    ang_step = PRECISION_ANGLE_STEP.get(p.precisione, 5.0)
+
+    return {
+        "num_features": nf,
+        "weak_grad": tune["weak_grad"],
+        "strong_grad": tune["strong_grad"],
+        "spread_radius": spread,
+        "pyramid_levels": pyr,
+        "angle_min": 0.0,
+        "angle_max": angle_max,
+        "angle_step": ang_step,
+        "scale_min": smin,
+        "scale_max": smax,
+        "scale_step": sstep,
+        "min_score": p.min_score,
+        "max_matches": p.max_matches,
+        "nms_radius": 0,
+        "verify_threshold": FILTRO_FP_MAP.get(p.filtro_fp, 0.35),
+        "scale_penalty": p.penalita_scala,
+    }
+
+
+# ---------------- Endpoints ----------------
+
+@app.get("/", response_class=HTMLResponse)
+def index():
+    html_path = STATIC_DIR / "index.html"
+    return HTMLResponse(html_path.read_text(encoding="utf-8"))
+
+
+@app.post("/upload_to_folder")
+async def upload_to_folder(file: UploadFile = File(...)):
+    """Salva file caricato nella cartella IMAGES_DIR. Ritorna lista aggiornata."""
+    if not IMAGES_DIR.is_dir():
+        raise HTTPException(500, f"IMAGES_DIR non esiste: {IMAGES_DIR}")
+    # Sanitizza nome file (no traversal)
+    name = Path(file.filename or "upload.png").name
+    if not name:
+        raise HTTPException(400, "nome file vuoto")
+    ext = Path(name).suffix.lower()
+    allowed = {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff"}
+    if ext not in allowed:
+        raise HTTPException(400, f"estensione non supportata: {ext}")
+    # Leggi contenuto e valida come immagine
+    data = await file.read()
+    arr = np.frombuffer(data, dtype=np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "file non è un'immagine valida")
+    # Evita overwrite: se esiste, aggiungi suffisso numerico
+    target = IMAGES_DIR / name
+    if target.exists():
+        stem = target.stem; suffix = target.suffix
+        i = 1
+        while True:
+            alt = IMAGES_DIR / f"{stem}_{i}{suffix}"
+            if not alt.exists():
+                target = alt; break
+            i += 1
+    # Scrivi su disco
+    with open(target, "wb") as f:
+        f.write(data)
+    # Ritorna lista aggiornata
+    return {
+        "saved_as": target.name,
+        "dir": str(IMAGES_DIR),
+        "files": sorted(
+            p.name for p in IMAGES_DIR.iterdir()
+            if p.is_file() and p.suffix.lower() in allowed
+        ),
+    }
+
+
+@app.get("/folder_image/{filename}")
+def folder_image(filename: str, w: int = 120):
+    """Serve thumbnail PNG dell'immagine IMAGES_DIR (scalata a width w)."""
+    if "/" in filename or ".." in filename:
+        raise HTTPException(400, "nome non valido")
+    path = IMAGES_DIR / filename
+    if not path.is_file():
+        raise HTTPException(404, "non trovato")
+    img = cv2.imread(str(path), cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "non leggibile")
+    h0, w0 = img.shape[:2]
+    if w0 > w:
+        sc = w / w0
+        img = cv2.resize(img, (w, int(h0 * sc)), interpolation=cv2.INTER_AREA)
+    return Response(_encode_png(img), media_type="image/png",
+                    headers={"Cache-Control": "public, max-age=3600"})
+
+
+@app.get("/images")
+def list_images():
+    """Lista file immagine nella cartella configurata in IMAGES_DIR."""
+    if not IMAGES_DIR.is_dir():
+        return {"dir": str(IMAGES_DIR), "files": []}
+    exts = {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff"}
+    files = sorted(
+        p.name for p in IMAGES_DIR.iterdir()
+        if p.is_file() and p.suffix.lower() in exts
+    )
+    return {"dir": str(IMAGES_DIR), "files": files}
+
+
+class LoadFolderReq(BaseModel):
+    filename: str
+
+
+@app.post("/load_from_folder", response_model=UploadResp)
+def load_from_folder(req: LoadFolderReq):
+    """Carica immagine dalla cartella IMAGES_DIR per nome file."""
+    name = req.filename
+    if "/" in name or ".." in name:
+        raise HTTPException(400, "nome file non valido")
+    path = IMAGES_DIR / name
+    if not path.is_file():
+        raise HTTPException(404, f"file non trovato: {name}")
+    img = cv2.imread(str(path), cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "immagine non leggibile")
+    iid = _store_image(img)
+    return UploadResp(id=iid, width=img.shape[1], height=img.shape[0])
+
+
+@app.post("/upload", response_model=UploadResp)
+async def upload(file: UploadFile = File(...)):
+    data = await file.read()
+    arr = np.frombuffer(data, dtype=np.uint8)
+    img = cv2.imdecode(arr, cv2.IMREAD_COLOR)
+    if img is None:
+        raise HTTPException(400, "Immagine non valida")
+    iid = _store_image(img)
+    return UploadResp(id=iid, width=img.shape[1], height=img.shape[0])
+
+
+@app.get("/image/{iid}/raw")
+def image_raw(iid: str):
+    img = _load_image(iid)
+    if img is None:
+        raise HTTPException(404, "Image not found")
+    return Response(_encode_png(img), media_type="image/png")
+
+
+@app.post("/match", response_model=MatchResp)
+def match(p: MatchParams):
+    model = _load_image(p.model_id)
+    scene = _load_image(p.scene_id)
+    if model is None or scene is None:
+        raise HTTPException(404, "Immagini non trovate")
+    x, y, w, h = p.roi
+    x = max(0, x); y = max(0, y)
+    w = max(1, min(w, model.shape[1] - x))
+    h = max(1, min(h, model.shape[0] - y))
+    roi_img = model[y:y + h, x:x + w]
+
+    tech_for_cache = {
+        "num_features": p.num_features,
+        "weak_grad": p.weak_grad, "strong_grad": p.strong_grad,
+        "angle_min": p.angle_min, "angle_max": p.angle_max,
+        "angle_step": p.angle_step,
+        "scale_min": p.scale_min, "scale_max": p.scale_max,
+        "scale_step": p.scale_step,
+        "spread_radius": p.spread_radius,
+        "pyramid_levels": p.pyramid_levels,
+    }
+    key = _matcher_cache_key(roi_img, tech_for_cache)
+    m = _cache_get_matcher(key)
+    if m is None:
+        m = LineShapeMatcher(
+            num_features=p.num_features,
+            weak_grad=p.weak_grad, strong_grad=p.strong_grad,
+            angle_range_deg=(p.angle_min, p.angle_max),
+            angle_step_deg=p.angle_step,
+            scale_range=(p.scale_min, p.scale_max),
+            scale_step=p.scale_step,
+            spread_radius=p.spread_radius,
+            pyramid_levels=p.pyramid_levels,
+        )
+        t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+        _cache_put_matcher(key, m)
+    else:
+        n = len(m.variants); t_train = 0.0
+    nms = p.nms_radius if p.nms_radius > 0 else None
+    t0 = time.time()
+    matches = m.find(
+        scene, min_score=p.min_score, max_matches=p.max_matches,
+        nms_radius=nms, verify_threshold=p.verify_threshold,
+    )
+    t_find = time.time() - t0
+
+    # Render annotated image
+    tg = cv2.cvtColor(roi_img, cv2.COLOR_BGR2GRAY)
+    annotated = _draw_matches(scene, matches, tg)
+    ann_id = _store_image(annotated)
+
+    return MatchResp(
+        matches=[MatchResult(
+            cx=m_.cx, cy=m_.cy, angle_deg=m_.angle_deg, scale=m_.scale,
+            score=m_.score,
+            bbox_poly=m_.bbox_poly.tolist(),
+        ) for m_ in matches],
+        train_time=t_train, find_time=t_find,
+        num_variants=n, annotated_id=ann_id,
+    )
+
+
+@app.post("/match_simple", response_model=MatchResp)
+def match_simple(p: SimpleMatchParams):
+    """Match con parametri user-facing (tipo/simmetria/scala/precisione).
+
+    Il server deriva i parametri tecnici (num_features, soglie gradiente,
+    piramide, ecc.) dall'analisi automatica della ROI.
+    """
+    model = _load_image(p.model_id)
+    scene = _load_image(p.scene_id)
+    if model is None or scene is None:
+        raise HTTPException(404, "Immagini non trovate")
+    x, y, w, h = p.roi
+    x = max(0, x); y = max(0, y)
+    w = max(1, min(w, model.shape[1] - x))
+    h = max(1, min(h, model.shape[0] - y))
+    roi_img = model[y:y + h, x:x + w]
+
+    tech = _simple_to_technical(p, roi_img)
+
+    key = _matcher_cache_key(roi_img, tech)
+    m = _cache_get_matcher(key)
+    if m is None:
+        m = LineShapeMatcher(
+            num_features=tech["num_features"],
+            weak_grad=tech["weak_grad"], strong_grad=tech["strong_grad"],
+            angle_range_deg=(tech["angle_min"], tech["angle_max"]),
+            angle_step_deg=tech["angle_step"],
+            scale_range=(tech["scale_min"], tech["scale_max"]),
+            scale_step=tech["scale_step"],
+            spread_radius=tech["spread_radius"],
+            pyramid_levels=tech["pyramid_levels"],
+        )
+        t0 = time.time(); n = m.train(roi_img); t_train = time.time() - t0
+        _cache_put_matcher(key, m)
+    else:
+        n = len(m.variants); t_train = 0.0
+    nms = tech["nms_radius"] if tech["nms_radius"] > 0 else None
+    t0 = time.time()
+    matches = m.find(
+        scene, min_score=tech["min_score"], max_matches=tech["max_matches"],
+        nms_radius=nms, verify_threshold=tech["verify_threshold"],
+        scale_penalty=tech.get("scale_penalty", 0.0),
+    )
+    t_find = time.time() - t0
+
+    tg = cv2.cvtColor(roi_img, cv2.COLOR_BGR2GRAY)
+    annotated = _draw_matches(scene, matches, tg)
+    ann_id = _store_image(annotated)
+
+    return MatchResp(
+        matches=[MatchResult(
+            cx=mt.cx, cy=mt.cy, angle_deg=mt.angle_deg, scale=mt.scale,
+            score=mt.score, bbox_poly=mt.bbox_poly.tolist(),
+        ) for mt in matches],
+        train_time=t_train, find_time=t_find,
+        num_variants=n, annotated_id=ann_id,
+    )
+
+
+@app.post("/auto_tune")
+def tune(p: TuneParams):
+    model = _load_image(p.model_id)
+    if model is None:
+        raise HTTPException(404, "Immagine non trovata")
+    x, y, w, h = p.roi
+    roi_img = model[y:y + h, x:x + w]
+    t = auto_tune(roi_img)
+    return {k: v for k, v in t.items() if not k.startswith("_")}
+
+
+# Mount static
+app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+def serve(host: str = "127.0.0.1", port: int = 8080):
+    import uvicorn
+    uvicorn.run(app, host=host, port=port, log_level="info")
+
+
+if __name__ == "__main__":
+    serve()

pm2d/web/static/app.js

@@ -0,0 +1,399 @@
+// Pattern Matching 2D - frontend (UI semplificata operator-friendly)
+
+// Parametri avanzati (sezione collassabile)
+const ADV_PARAMS = [
+  ["num_features", "Num feature", "int", ""],
+  ["weak_grad", "Weak grad", "float", ""],
+  ["strong_grad", "Strong grad", "float", ""],
+  ["spread_radius", "Spread radius", "int", ""],
+  ["pyramid_levels", "Pyramid levels", "int", ""],
+  ["verify_threshold", "Verify NCC thr", "float", 0.4],
+  ["nms_radius", "NMS radius (0=auto)", "int", 0],
+];
+
+const PALETTE = [
+  "#00ff00", "#ffc800", "#ff6464", "#ffc800", "#c800ff",
+  "#64ffc8", "#ff0000", "#00ffff",
+];
+
+const state = {
+  model: null, scene: null, roi: null, drag: null,
+  matches: [], annotatedImg: null,
+};
+
+// ---------- Forms ----------
+function buildAdvancedForm() {
+  const form = document.getElementById("adv-form");
+  form.innerHTML = "";
+  for (const [key, label, , def] of ADV_PARAMS) {
+    const lbl = document.createElement("label");
+    lbl.textContent = label;
+    const inp = document.createElement("input");
+    inp.id = `adv-${key}`;
+    inp.type = "text";
+    inp.placeholder = "auto";
+    inp.value = def === "" ? "" : String(def);
+    inp.addEventListener("keydown", (e) => {
+      if (e.key === "Enter") doMatch();
+    });
+    form.appendChild(lbl);
+    form.appendChild(inp);
+  }
+}
+
+function readUserParams() {
+  return {
+    tipo: document.getElementById("p-tipo").value,
+    simmetria: document.getElementById("p-simmetria").value,
+    scala: document.getElementById("p-scala").value,
+    precisione: document.getElementById("p-precisione").value,
+    filtro_fp: document.getElementById("p-filtro-fp").value,
+    penalita_scala: parseFloat(
+      document.getElementById("p-penalita-scala").value),
+    min_score: parseFloat(document.getElementById("p-min-score").value),
+    max_matches: parseInt(document.getElementById("p-max-matches").value, 10),
+  };
+}
+
+function readAdvancedOverrides() {
+  const out = {};
+  for (const [key, , type] of ADV_PARAMS) {
+    const v = document.getElementById(`adv-${key}`).value.trim();
+    if (v === "") continue;
+    out[key] = type === "int" ? parseInt(v, 10) : parseFloat(v);
+  }
+  return out;
+}
+
+// ---------- Image loading from folder ----------
+async function loadFromFolder(filename) {
+  const r = await fetch("/load_from_folder", {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ filename }),
+  });
+  if (!r.ok) throw new Error(await r.text());
+  return await r.json();
+}
+
+async function fetchImagesList() {
+  const r = await fetch("/images");
+  if (!r.ok) return { files: [], dir: "" };
+  return await r.json();
+}
+
+async function uploadToFolder(file) {
+  const fd = new FormData();
+  fd.append("file", file);
+  const r = await fetch("/upload_to_folder", { method: "POST", body: fd });
+  if (!r.ok) throw new Error(await r.text());
+  return await r.json();
+}
+
+async function refreshPickers() {
+  const {files, dir} = await fetchImagesList();
+  buildThumbPicker("picker-model", files, onSelectModel);
+  buildThumbPicker("picker-scene", files, onSelectScene);
+  return {files, dir};
+}
+
+function buildThumbPicker(pickerId, files, onSelect) {
+  const picker = document.getElementById(pickerId);
+  const current = picker.querySelector(".picker-current");
+  const list = picker.querySelector(".picker-list");
+  const text = current.querySelector(".picker-text");
+  // Rimuovi eventuale vecchia thumbnail
+  const oldImg = current.querySelector("img");
+  if (oldImg) oldImg.remove();
+  list.innerHTML = "";
+
+  files.forEach((f) => {
+    const item = document.createElement("div");
+    item.className = "picker-item";
+    const img = document.createElement("img");
+    img.src = `/folder_image/${encodeURIComponent(f)}?w=120`;
+    img.loading = "lazy";
+    const name = document.createElement("span");
+    name.className = "name"; name.textContent = f;
+    item.appendChild(img); item.appendChild(name);
+    item.addEventListener("click", () => {
+      // Aggiorna la visual del "current"
+      let thumb = current.querySelector("img");
+      if (!thumb) {
+        thumb = document.createElement("img");
+        current.insertBefore(thumb, text);
+      }
+      thumb.src = `/folder_image/${encodeURIComponent(f)}?w=80`;
+      text.textContent = f;
+      picker.classList.remove("open");
+      onSelect(f);
+    });
+    list.appendChild(item);
+  });
+
+  current.onclick = () => {
+    // Chiudi altri picker aperti
+    document.querySelectorAll(".thumb-picker.open")
+      .forEach((p) => { if (p !== picker) p.classList.remove("open"); });
+    picker.classList.toggle("open");
+  };
+}
+
+// Close picker on outside click
+document.addEventListener("click", (e) => {
+  if (!e.target.closest(".thumb-picker")) {
+    document.querySelectorAll(".thumb-picker.open")
+      .forEach((p) => p.classList.remove("open"));
+  }
+});
+
+function loadImage(src) {
+  return new Promise((res, rej) => {
+    const img = new Image();
+    img.onload = () => res(img);
+    img.onerror = rej;
+    img.src = src;
+  });
+}
+
+async function onSelectModel(filename) {
+  if (!filename) return;
+  setStatus("Caricamento modello...");
+  try {
+    const meta = await loadFromFolder(filename);
+    const img = await loadImage(`/image/${meta.id}/raw`);
+    state.model = { id: meta.id, w: meta.width, h: meta.height, img };
+    state.roi = null;
+    document.getElementById("roi-info").textContent = "ROI: (nessuna)";
+    setStatus(`Modello: ${filename} ${meta.width}x${meta.height} — trascina ROI`);
+    renderModel();
+  } catch (e) {
+    setStatus(`Errore modello: ${e.message}`);
+  }
+}
+
+async function onSelectScene(filename) {
+  if (!filename) return;
+  setStatus("Caricamento scena...");
+  try {
+    const meta = await loadFromFolder(filename);
+    const img = await loadImage(`/image/${meta.id}/raw`);
+    state.scene = { id: meta.id, w: meta.width, h: meta.height, img };
+    state.matches = []; state.annotatedImg = null;
+    setStatus(`Scena: ${filename} ${meta.width}x${meta.height}`);
+    renderScene();
+  } catch (e) {
+    setStatus(`Errore scena: ${e.message}`);
+  }
+}
+
+// ---------- Rendering ----------
+function fitToCanvas(img, cw, ch) {
+  const sc = Math.min(cw / img.width, ch / img.height);
+  const dw = img.width * sc, dh = img.height * sc;
+  return { sc, ox: (cw - dw) / 2, oy: (ch - dh) / 2, dw, dh };
+}
+
+function renderModel() {
+  const cnv = document.getElementById("c-model");
+  const ctx = cnv.getContext("2d");
+  ctx.fillStyle = "#141414";
+  ctx.fillRect(0, 0, cnv.width, cnv.height);
+  if (!state.model) return;
+  const fit = fitToCanvas(state.model.img, cnv.width, cnv.height);
+  state.model.scale = fit.sc;
+  state.model.ox = fit.ox; state.model.oy = fit.oy;
+  ctx.drawImage(state.model.img, fit.ox, fit.oy, fit.dw, fit.dh);
+  if (state.roi) {
+    const [x, y, w, h] = state.roi;
+    ctx.strokeStyle = "#00ff80"; ctx.lineWidth = 2;
+    ctx.strokeRect(fit.ox + x * fit.sc, fit.oy + y * fit.sc,
+                   w * fit.sc, h * fit.sc);
+  }
+  if (state.drag) {
+    ctx.strokeStyle = "#ffff00";
+    ctx.setLineDash([4, 2]); ctx.lineWidth = 2;
+    ctx.strokeRect(
+      Math.min(state.drag.x0, state.drag.x1),
+      Math.min(state.drag.y0, state.drag.y1),
+      Math.abs(state.drag.x1 - state.drag.x0),
+      Math.abs(state.drag.y1 - state.drag.y0));
+    ctx.setLineDash([]);
+  }
+}
+
+function renderScene() {
+  const cnv = document.getElementById("c-scene");
+  const ctx = cnv.getContext("2d");
+  ctx.fillStyle = "#141414";
+  ctx.fillRect(0, 0, cnv.width, cnv.height);
+  const img = state.annotatedImg || (state.scene && state.scene.img);
+  if (!img) return;
+  const fit = fitToCanvas(img, cnv.width, cnv.height);
+  ctx.drawImage(img, fit.ox, fit.oy, fit.dw, fit.dh);
+}
+
+// ---------- ROI drag ----------
+function canvasPos(cnv, ev) {
+  const r = cnv.getBoundingClientRect();
+  return { x: ev.clientX - r.left, y: ev.clientY - r.top };
+}
+
+function setupROI() {
+  const cnv = document.getElementById("c-model");
+  cnv.addEventListener("mousedown", (e) => {
+    if (!state.model) return;
+    const p = canvasPos(cnv, e);
+    state.drag = { x0: p.x, y0: p.y, x1: p.x, y1: p.y };
+    renderModel();
+  });
+  cnv.addEventListener("mousemove", (e) => {
+    if (!state.drag) return;
+    const p = canvasPos(cnv, e);
+    state.drag.x1 = p.x; state.drag.y1 = p.y;
+    renderModel();
+  });
+  cnv.addEventListener("mouseup", () => {
+    if (!state.drag || !state.model) return;
+    const d = state.drag; state.drag = null;
+    if (Math.abs(d.x1 - d.x0) < 4 || Math.abs(d.y1 - d.y0) < 4) return;
+    const m = state.model;
+    const ix0 = Math.round((Math.min(d.x0, d.x1) - m.ox) / m.scale);
+    const iy0 = Math.round((Math.min(d.y0, d.y1) - m.oy) / m.scale);
+    const iw = Math.round(Math.abs(d.x1 - d.x0) / m.scale);
+    const ih = Math.round(Math.abs(d.y1 - d.y0) / m.scale);
+    const cx0 = Math.max(0, Math.min(ix0, m.w - 1));
+    const cy0 = Math.max(0, Math.min(iy0, m.h - 1));
+    const cw = Math.max(1, Math.min(iw, m.w - cx0));
+    const ch = Math.max(1, Math.min(ih, m.h - cy0));
+    state.roi = [cx0, cy0, cw, ch];
+    document.getElementById("roi-info").textContent =
+      `ROI: ${cw}x${ch} @ (${cx0}, ${cy0})`;
+    renderModel();
+  });
+}
+
+// ---------- Match action ----------
+async function doMatch() {
+  if (!state.model) { setStatus("Carica modello"); return; }
+  if (!state.scene) { setStatus("Carica scena"); return; }
+  if (!state.roi) { setStatus("Seleziona ROI sul modello"); return; }
+  const user = readUserParams();
+  const adv = readAdvancedOverrides();
+  setStatus("Match in corso...");
+
+  // Se utente ha fornito override avanzati → usa /match (tecnico)
+  // altrimenti /match_simple (operator mode)
+  const hasAdv = Object.keys(adv).length > 0;
+  const url = hasAdv ? "/match" : "/match_simple";
+  let body;
+  if (hasAdv) {
+    // Merge simple → tecnici base, poi overrides
+    const SYM_MAP = {invariante:0, nessuna:360, bilaterale:180, rot_3:120,
+                     rot_4:90, rot_6:60, rot_8:45};
+    const SCALE_MAP = {fissa:[1,1,0.1], mini:[0.9,1.1,0.05],
+                       medio:[0.75,1.25,0.05], max:[0.5,1.5,0.05]};
+    const PREC_MAP = {veloce:10, normale:5, preciso:2};
+    const FP_MAP = {off:0, leggero:0.20, medio:0.35, forte:0.50};
+    const [smin, smax, sstep] = SCALE_MAP[user.scala];
+    body = {
+      model_id: state.model.id, scene_id: state.scene.id, roi: state.roi,
+      angle_min: 0, angle_max: SYM_MAP[user.simmetria] || 360,
+      angle_step: PREC_MAP[user.precisione] || 5,
+      scale_min: smin, scale_max: smax, scale_step: sstep,
+      min_score: user.min_score, max_matches: user.max_matches,
+      num_features: adv.num_features ?? 96,
+      weak_grad: adv.weak_grad ?? 30,
+      strong_grad: adv.strong_grad ?? 60,
+      spread_radius: adv.spread_radius ?? 5,
+      pyramid_levels: adv.pyramid_levels ?? 3,
+      verify_threshold: adv.verify_threshold ?? (FP_MAP[user.filtro_fp] ?? 0.35),
+      nms_radius: adv.nms_radius ?? 0,
+    };
+  } else {
+    body = {
+      model_id: state.model.id, scene_id: state.scene.id, roi: state.roi,
+      ...user,
+    };
+  }
+
+  const r = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!r.ok) {
+    setStatus(`Errore: ${await r.text()}`); return;
+  }
+  const data = await r.json();
+  state.matches = data.matches;
+  state.annotatedImg = await loadImage(
+    `/image/${data.annotated_id}/raw?t=${Date.now()}`);
+  renderScene();
+  renderLegend();
+  document.getElementById("t-train").textContent = `${data.train_time.toFixed(2)}s`;
+  document.getElementById("t-find").textContent = `${data.find_time.toFixed(2)}s`;
+  document.getElementById("t-var").textContent = data.num_variants;
+  document.getElementById("t-match").textContent = data.matches.length;
+  setStatus(`${data.matches.length} match trovati${hasAdv ? " (avanzato)" : ""}`);
+}
+
+function renderLegend() {
+  const el = document.getElementById("legend");
+  el.innerHTML = "";
+  state.matches.forEach((m, i) => {
+    const div = document.createElement("div");
+    div.className = "legend-item";
+    const dot = document.createElement("span");
+    dot.className = "legend-dot";
+    dot.style.background = PALETTE[i % PALETTE.length];
+    div.appendChild(dot);
+    const txt = document.createElement("span");
+    txt.textContent = `#${i+1}  cx=${Math.round(m.cx)} cy=${Math.round(m.cy)}  `
+      + `${m.angle_deg.toFixed(1)}°  s=${m.scale.toFixed(2)}  `
+      + `score=${m.score.toFixed(3)}`;
+    div.appendChild(txt);
+    el.appendChild(div);
+  });
+}
+
+function setStatus(s) {
+  document.getElementById("status").textContent = s;
+}
+
+// ---------- Init ----------
+window.addEventListener("DOMContentLoaded", async () => {
+  buildAdvancedForm();
+  setupROI();
+  // Popola picker immagini da IMAGES_DIR (con thumbnail)
+  const {files, dir} = await refreshPickers();
+  if (files.length === 0) {
+    setStatus(`Nessuna immagine in ${dir} (carica file o configura IMAGES_DIR)`);
+  } else {
+    setStatus(`${files.length} immagini in ${dir}`);
+  }
+
+  // Upload file nella folder
+  const upEl = document.getElementById("file-upload");
+  upEl.addEventListener("change", async (e) => {
+    const f = e.target.files[0];
+    if (!f) return;
+    setStatus(`Caricamento ${f.name} nella cartella...`);
+    try {
+      const res = await uploadToFolder(f);
+      await refreshPickers();
+      setStatus(`Salvato come ${res.saved_as} (${res.files.length} file totali)`);
+    } catch (err) {
+      setStatus(`Errore upload: ${err.message}`);
+    }
+    e.target.value = "";  // consente re-upload stesso file
+  });
+  document.getElementById("btn-match").addEventListener("click", doMatch);
+  const slider = document.getElementById("p-min-score");
+  slider.addEventListener("input", (e) => {
+    document.getElementById("v-score").textContent =
+      parseFloat(e.target.value).toFixed(2);
+  });
+  renderModel();
+  renderScene();
+});

pm2d/web/static/index.html

@@ -0,0 +1,152 @@
+<!doctype html>
+<html lang="it">
+<head>
+<meta charset="utf-8" />
+<title>Pattern Matching 2D</title>
+<link rel="stylesheet" href="/static/style.css">
+</head>
+<body>
+<header>
+  <h1>Pattern Matching 2D</h1>
+  <div class="toolbar">
+    <label class="tb-label">Modello:</label>
+    <div class="thumb-picker" id="picker-model">
+      <div class="picker-current" tabindex="0">
+        <span class="picker-text">-- seleziona --</span>
+        <span class="caret">▾</span>
+      </div>
+      <div class="picker-list"></div>
+    </div>
+    <label class="tb-label">Scena:</label>
+    <div class="thumb-picker" id="picker-scene">
+      <div class="picker-current" tabindex="0">
+        <span class="picker-text">-- seleziona --</span>
+        <span class="caret">▾</span>
+      </div>
+      <div class="picker-list"></div>
+    </div>
+    <button class="btn btn-go" id="btn-match">▶ MATCH</button>
+    <label class="btn" title="Carica nuovo file nella cartella immagini">
+      ⬆ Carica file
+      <input type="file" id="file-upload" accept="image/*" hidden>
+    </label>
+    <span id="status">Seleziona modello, disegna ROI, seleziona scena</span>
+  </div>
+</header>
+
+<main>
+  <section class="col" id="col-model">
+    <h2>MODELLO</h2>
+    <div class="canvas-wrap">
+      <canvas id="c-model" width="380" height="420"></canvas>
+    </div>
+    <div id="roi-info">ROI: (nessuna)</div>
+  </section>
+
+  <section class="col" id="col-scene">
+    <h2>SCENA</h2>
+    <div class="canvas-wrap">
+      <canvas id="c-scene" width="820" height="620"></canvas>
+    </div>
+  </section>
+
+  <section class="col" id="col-params">
+    <h2>IMPOSTAZIONI</h2>
+
+    <div class="field">
+      <label>Tipo modello</label>
+      <select id="p-tipo">
+        <option value="intero">Oggetto intero</option>
+        <option value="parziale">Parte di oggetto</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Simmetria</label>
+      <select id="p-simmetria">
+        <option value="invariante">Invariante (cerchi — no rotazione)</option>
+        <option value="nessuna">Nessuna (0..360°)</option>
+        <option value="bilaterale">Bilaterale (speculare 180°)</option>
+        <option value="rot_3">Rotazionale 3× (120°)</option>
+        <option value="rot_4">Rotazionale 4× (90°)</option>
+        <option value="rot_6">Rotazionale 6× (60°)</option>
+        <option value="rot_8">Rotazionale 8× (45°)</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Variazione scala</label>
+      <select id="p-scala">
+        <option value="fissa">Fissa (setup calibrato)</option>
+        <option value="mini">±10%</option>
+        <option value="medio">±25%</option>
+        <option value="max">±50%</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Precisione angolare</label>
+      <select id="p-precisione">
+        <option value="veloce">Veloce (10°)</option>
+        <option value="normale" selected>Normale (5°)</option>
+        <option value="preciso">Preciso (2°)</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Filtro falsi positivi
+        <span class="hint">(verifica intensità colori)</span>
+      </label>
+      <select id="p-filtro-fp">
+        <option value="off">Disattivato (massimo recall)</option>
+        <option value="leggero">Leggero (tollera illuminazione)</option>
+        <option value="medio" selected>Medio (consigliato)</option>
+        <option value="forte">Forte (massima selettività)</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Peso dimensione nel score
+        <span class="hint">(penalizza scala ≠ 1.0)</span>
+      </label>
+      <select id="p-penalita-scala">
+        <option value="0" selected>Nessuno (score shape puro)</option>
+        <option value="0.3">Leggero (−30% max)</option>
+        <option value="0.5">Medio (−50% max)</option>
+        <option value="0.8">Forte (−80% max)</option>
+      </select>
+    </div>
+
+    <div class="field">
+      <label>Score minimo <span id="v-score">0.65</span>
+        <span class="hint">(più basso = più match anche incerti)</span>
+      </label>
+      <input type="range" id="p-min-score" min="0.30" max="0.95" step="0.05" value="0.65">
+    </div>
+
+    <div class="field">
+      <label>Max match</label>
+      <input type="number" id="p-max-matches" value="25" min="1" max="200">
+    </div>
+
+    <details>
+      <summary>Avanzate</summary>
+      <div id="adv-form"></div>
+    </details>
+
+    <h2 style="margin-top:14px">TEMPI</h2>
+    <div class="kv"><span>train:</span><span id="t-train">-</span></div>
+    <div class="kv"><span>find:</span><span id="t-find">-</span></div>
+    <div class="kv"><span>varianti:</span><span id="t-var">-</span></div>
+    <div class="kv"><span>match:</span><span id="t-match">-</span></div>
+  </section>
+</main>
+
+<footer>
+  <h2>LEGENDA</h2>
+  <div id="legend"></div>
+</footer>
+
+<script src="/static/app.js"></script>
+</body>
+</html>

pm2d/web/static/style.css

@@ -0,0 +1,158 @@
+* { box-sizing: border-box; }
+html, body {
+  margin: 0; padding: 0; background: #1a1a1a; color: #dcdcdc;
+  font-family: -apple-system, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+  font-size: 14px;
+  min-height: 100vh;
+}
+header {
+  background: #111; padding: 10px 16px; border-bottom: 1px solid #333;
+  position: sticky; top: 0; z-index: 10;
+}
+header h1 {
+  margin: 0 0 8px; font-size: 18px; color: #00c8ff;
+}
+.toolbar {
+  display: flex; gap: 10px; align-items: center; flex-wrap: wrap;
+}
+.btn {
+  display: inline-block; padding: 6px 14px; background: #2c2c2c;
+  border: 1px solid #444; color: #dcdcdc; cursor: pointer;
+  border-radius: 4px; font-size: 13px; line-height: 1.4;
+  transition: background 0.15s;
+}
+.btn:hover { background: #3a3a3a; }
+.btn-go {
+  background: #0a7d3a; border-color: #0d9c48; color: #fff; font-weight: bold;
+}
+.btn-go:hover { background: #0d9c48; }
+.tb-label { color: #b0b0b0; font-size: 12px; margin-left: 8px; }
+
+.thumb-picker { position: relative; display: inline-block; }
+.picker-current {
+  display: flex; align-items: center; gap: 8px;
+  background: #2a2a2a; color: #dcdcdc; border: 1px solid #444;
+  padding: 4px 8px; border-radius: 3px; font-size: 13px;
+  cursor: pointer; min-width: 200px; min-height: 32px;
+}
+.picker-current:hover { background: #353535; }
+.picker-current img {
+  width: 36px; height: 36px; object-fit: contain;
+  background: #141414; border-radius: 2px;
+}
+.picker-text { flex: 1; white-space: nowrap; overflow: hidden;
+  text-overflow: ellipsis; }
+.caret { color: #888; font-size: 10px; }
+.picker-list {
+  display: none; position: absolute; top: 100%; left: 0;
+  background: #232323; border: 1px solid #444; border-radius: 3px;
+  margin-top: 2px; z-index: 100; max-height: 360px; overflow-y: auto;
+  box-shadow: 0 4px 12px rgba(0,0,0,0.6); min-width: 280px;
+}
+.thumb-picker.open .picker-list { display: block; }
+.picker-item {
+  display: flex; align-items: center; gap: 10px;
+  padding: 6px 10px; cursor: pointer; border-bottom: 1px solid #2a2a2a;
+}
+.picker-item:hover { background: #2e2e2e; }
+.picker-item img {
+  width: 60px; height: 60px; object-fit: contain;
+  background: #141414; border-radius: 2px;
+}
+.picker-item .name { color: #dcdcdc; font-size: 13px; }
+#status {
+  color: #00c8ff; margin-left: 12px; font-weight: 500;
+}
+
+main {
+  display: grid;
+  grid-template-columns: 420px 1fr 360px;
+  gap: 12px;
+  padding: 12px 16px;
+}
+.col {
+  background: #232323; padding: 10px;
+  border: 1px solid #333; border-radius: 4px;
+}
+.col h2 {
+  margin: 0 0 8px; font-size: 13px; color: #00c8ff;
+  letter-spacing: 1px; text-transform: uppercase;
+}
+.canvas-wrap {
+  background: #141414; border: 1px solid #444;
+  display: inline-block; position: relative;
+}
+canvas {
+  display: block; cursor: crosshair;
+  image-rendering: pixelated;
+}
+#roi-info {
+  margin-top: 6px; font-size: 12px; color: #aaa;
+}
+
+.field {
+  margin-bottom: 10px;
+}
+.field label {
+  display: block; font-size: 12px; color: #b0b0b0;
+  margin-bottom: 3px;
+}
+.field select, .field input {
+  width: 100%; background: #2a2a2a; color: #dcdcdc;
+  border: 1px solid #444; padding: 5px 6px; border-radius: 3px;
+  font-size: 12px;
+}
+.field input[type="range"] {
+  padding: 0; height: 26px;
+}
+.field select:focus, .field input:focus {
+  outline: 1px solid #00c8ff;
+}
+
+#v-score { color: #00c8ff; font-weight: bold; }
+.hint { color: #777; font-size: 10px; font-weight: normal; margin-left: 4px; }
+
+details { margin-top: 10px; font-size: 12px; }
+details summary {
+  cursor: pointer; padding: 4px 0; color: #00c8ff;
+}
+#adv-form {
+  display: grid; grid-template-columns: 1fr 80px; gap: 3px 6px;
+  margin-top: 4px;
+}
+#adv-form label { font-size: 11px; color: #999; }
+#adv-form input {
+  background: #2a2a2a; color: #dcdcdc; border: 1px solid #444;
+  padding: 3px 5px; border-radius: 3px; font-size: 11px;
+  width: 100%;
+}
+
+.kv {
+  display: flex; justify-content: space-between;
+  padding: 3px 0; font-size: 12px; border-bottom: 1px dotted #333;
+}
+.kv span:last-child { color: #80ff80; font-weight: bold; }
+
+footer {
+  padding: 10px 16px; border-top: 1px solid #333;
+  min-height: 120px;
+}
+footer h2 {
+  margin: 0 0 8px; font-size: 13px; color: #00c8ff;
+  letter-spacing: 1px; text-transform: uppercase;
+}
+#legend {
+  display: grid;
+  grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
+  gap: 6px;
+}
+.legend-item {
+  display: flex; align-items: center; gap: 8px;
+  padding: 4px 6px; background: #232323;
+  border-radius: 3px; font-size: 12px; font-family: monospace;
+}
+.legend-dot {
+  width: 12px; height: 12px; border-radius: 50%; flex-shrink: 0;
+}
+
+#col-model, #col-scene { min-width: 0; }

pyproject.toml

@@ -3,7 +3,16 @@ name = "shape-model-2d"
 version = "0.1.0"
 requires-python = ">=3.13"
 dependencies = [
+    "fastapi>=0.115",
     "numba>=0.65.0",
     "numpy>=1.24",
     "opencv-python>=4.8",
+    "pillow>=12.2.0",
+    "python-multipart>=0.0.26",
+    "uvicorn[standard]>=0.34",
+]
+
+[dependency-groups]
+dev = [
+    "httpx>=0.28.1",
 ]

uv.lock

@@ -2,6 +2,150 @@ version = 1
 revision = 3
 requires-python = ">=3.13"
 
+[[package]]
+name = "annotated-doc"
+version = "0.0.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/57/ba/046ceea27344560984e26a590f90bc7f4a75b06701f653222458922b558c/annotated_doc-0.0.4.tar.gz", hash = "sha256:fbcda96e87e9c92ad167c2e53839e57503ecfda18804ea28102353485033faa4", size = 7288, upload-time = "2025-11-10T22:07:42.062Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1e/d3/26bf1008eb3d2daa8ef4cacc7f3bfdc11818d111f7e2d0201bc6e3b49d45/annotated_doc-0.0.4-py3-none-any.whl", hash = "sha256:571ac1dc6991c450b25a9c2d84a3705e2ae7a53467b5d111c24fa8baabbed320", size = 5303, upload-time = "2025-11-10T22:07:40.673Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/19/14/2c5dd9f512b66549ae92767a9c7b330ae88e1932ca57876909410251fe13/anyio-4.13.0.tar.gz", hash = "sha256:334b70e641fd2221c1505b3890c69882fe4a2df910cba14d97019b90b24439dc", size = 231622, upload-time = "2026-03-24T12:59:09.671Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/da/42/e921fccf5015463e32a3cf6ee7f980a6ed0f395ceeaa45060b61d86486c2/anyio-4.13.0-py3-none-any.whl", hash = "sha256:08b310f9e24a9594186fd75b4f73f4a4152069e3853f1ed8bfbf58369f4ad708", size = 114353, upload-time = "2026-03-24T12:59:08.246Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2026.4.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/25/ee/6caf7a40c36a1220410afe15a1cc64993a1f864871f698c0f93acb72842a/certifi-2026.4.22.tar.gz", hash = "sha256:8d455352a37b71bf76a79caa83a3d6c25afee4a385d632127b6afb3963f1c580", size = 137077, upload-time = "2026-04-22T11:26:11.191Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/30/7cd8fdcdfbc5b869528b079bfb76dcdf6056b1a2097a662e5e8c04f42965/certifi-2026.4.22-py3-none-any.whl", hash = "sha256:3cb2210c8f88ba2318d29b0388d1023c8492ff72ecdde4ebdaddbb13a31b1c4a", size = 135707, upload-time = "2026-04-22T11:26:09.372Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/bb/63/f9e1ea081ce35720d8b92acde70daaedace594dc93b693c869e0d5910718/click-8.3.3.tar.gz", hash = "sha256:398329ad4837b2ff7cbe1dd166a4c0f8900c3ca3a218de04466f38f6497f18a2", size = 328061, upload-time = "2026-04-22T15:11:27.506Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ae/44/c1221527f6a71a01ec6fbad7fa78f1d50dfa02217385cf0fa3eec7087d59/click-8.3.3-py3-none-any.whl", hash = "sha256:a2bf429bb3033c89fa4936ffb35d5cb471e3719e1f3c8a7c3fff0b8314305613", size = 110502, upload-time = "2026-04-22T15:11:25.044Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "fastapi"
+version = "0.136.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-doc" },
+    { name = "pydantic" },
+    { name = "starlette" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/5d/45/c130091c2dfa061bbfe3150f2a5091ef1adf149f2a8d2ae769ecaf6e99a2/fastapi-0.136.1.tar.gz", hash = "sha256:7af665ad7acfa0a3baf8983d393b6b471b9da10ede59c60045f49fbc89a0fa7f", size = 397448, upload-time = "2026-04-23T16:49:44.046Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5a/ff/2e4eca3ade2c22fe1dea7043b8ee9dabe47753349eb1b56a202de8af6349/fastapi-0.136.1-py3-none-any.whl", hash = "sha256:a6e9d7eeada96c93a4d69cb03836b44fa34e2854accb7244a1ece36cd4781c3f", size = 117683, upload-time = "2026-04-23T16:49:42.437Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httptools"
+version = "0.7.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b5/46/120a669232c7bdedb9d52d4aeae7e6c7dfe151e99dc70802e2fc7a5e1993/httptools-0.7.1.tar.gz", hash = "sha256:abd72556974f8e7c74a259655924a717a2365b236c882c3f6f8a45fe94703ac9", size = 258961, upload-time = "2025-10-10T03:55:08.559Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/09/8f/c77b1fcbfd262d422f12da02feb0d218fa228d52485b77b953832105bb90/httptools-0.7.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6babce6cfa2a99545c60bfef8bee0cc0545413cb0018f617c8059a30ad985de3", size = 202889, upload-time = "2025-10-10T03:54:47.089Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1a/22887f53602feaa066354867bc49a68fc295c2293433177ee90870a7d517/httptools-0.7.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:601b7628de7504077dd3dcb3791c6b8694bbd967148a6d1f01806509254fb1ca", size = 108180, upload-time = "2025-10-10T03:54:48.052Z" },
+    { url = "https://files.pythonhosted.org/packages/32/6a/6aaa91937f0010d288d3d124ca2946d48d60c3a5ee7ca62afe870e3ea011/httptools-0.7.1-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:04c6c0e6c5fb0739c5b8a9eb046d298650a0ff38cf42537fc372b28dc7e4472c", size = 478596, upload-time = "2025-10-10T03:54:48.919Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/70/023d7ce117993107be88d2cbca566a7c1323ccbaf0af7eabf2064fe356f6/httptools-0.7.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:69d4f9705c405ae3ee83d6a12283dc9feba8cc6aaec671b412917e644ab4fa66", size = 473268, upload-time = "2025-10-10T03:54:49.993Z" },
+    { url = "https://files.pythonhosted.org/packages/32/4d/9dd616c38da088e3f436e9a616e1d0cc66544b8cdac405cc4e81c8679fc7/httptools-0.7.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:44c8f4347d4b31269c8a9205d8a5ee2df5322b09bbbd30f8f862185bb6b05346", size = 455517, upload-time = "2025-10-10T03:54:51.066Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/3a/a6c595c310b7df958e739aae88724e24f9246a514d909547778d776799be/httptools-0.7.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:465275d76db4d554918aba40bf1cbebe324670f3dfc979eaffaa5d108e2ed650", size = 458337, upload-time = "2025-10-10T03:54:52.196Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/82/88e8d6d2c51edc1cc391b6e044c6c435b6aebe97b1abc33db1b0b24cd582/httptools-0.7.1-cp313-cp313-win_amd64.whl", hash = "sha256:322d00c2068d125bd570f7bf78b2d367dad02b919d8581d7476d8b75b294e3e6", size = 85743, upload-time = "2025-10-10T03:54:53.448Z" },
+    { url = "https://files.pythonhosted.org/packages/34/50/9d095fcbb6de2d523e027a2f304d4551855c2f46e0b82befd718b8b20056/httptools-0.7.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:c08fe65728b8d70b6923ce31e3956f859d5e1e8548e6f22ec520a962c6757270", size = 203619, upload-time = "2025-10-10T03:54:54.321Z" },
+    { url = "https://files.pythonhosted.org/packages/07/f0/89720dc5139ae54b03f861b5e2c55a37dba9a5da7d51e1e824a1f343627f/httptools-0.7.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7aea2e3c3953521c3c51106ee11487a910d45586e351202474d45472db7d72d3", size = 108714, upload-time = "2025-10-10T03:54:55.163Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/cb/eea88506f191fb552c11787c23f9a405f4c7b0c5799bf73f2249cd4f5228/httptools-0.7.1-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:0e68b8582f4ea9166be62926077a3334064d422cf08ab87d8b74664f8e9058e1", size = 472909, upload-time = "2025-10-10T03:54:56.056Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/4a/a548bdfae6369c0d078bab5769f7b66f17f1bfaa6fa28f81d6be6959066b/httptools-0.7.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:df091cf961a3be783d6aebae963cc9b71e00d57fa6f149025075217bc6a55a7b", size = 470831, upload-time = "2025-10-10T03:54:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/31/14df99e1c43bd132eec921c2e7e11cda7852f65619bc0fc5bdc2d0cb126c/httptools-0.7.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f084813239e1eb403ddacd06a30de3d3e09a9b76e7894dcda2b22f8a726e9c60", size = 452631, upload-time = "2025-10-10T03:54:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/22/d2/b7e131f7be8d854d48cb6d048113c30f9a46dca0c9a8b08fcb3fcd588cdc/httptools-0.7.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:7347714368fb2b335e9063bc2b96f2f87a9ceffcd9758ac295f8bbcd3ffbc0ca", size = 452910, upload-time = "2025-10-10T03:54:59.366Z" },
+    { url = "https://files.pythonhosted.org/packages/53/cf/878f3b91e4e6e011eff6d1fa9ca39f7eb17d19c9d7971b04873734112f30/httptools-0.7.1-cp314-cp314-win_amd64.whl", hash = "sha256:cfabda2a5bb85aa2a904ce06d974a3f30fb36cc63d7feaddec05d2050acede96", size = 88205, upload-time = "2025-10-10T03:55:00.389Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.13"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ce/cc/762dfb036166873f0059f3b7de4565e1b5bc3d6f28a414c13da27e442f99/idna-3.13.tar.gz", hash = "sha256:585ea8fe5d69b9181ec1afba340451fba6ba764af97026f92a91d4eef164a242", size = 194210, upload-time = "2026-04-22T16:42:42.314Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5d/13/ad7d7ca3808a898b4612b6fe93cde56b53f3034dcde235acb1f0e1df24c6/idna-3.13-py3-none-any.whl", hash = "sha256:892ea0cde124a99ce773decba204c5552b69c3c67ffd5f232eb7696135bc8bb3", size = 68629, upload-time = "2026-04-22T16:42:40.909Z" },
+]
+
 [[package]]
 name = "llvmlite"
 version = "0.47.0"
@@ -114,19 +258,394 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/e9/a5/1be1516390333ff9be3a9cb648c9f33df79d5096e5884b5df71a588af463/opencv_python-4.13.0.92-cp37-abi3-win_amd64.whl", hash = "sha256:423d934c9fafb91aad38edf26efb46da91ffbc05f3f59c4b0c72e699720706f5", size = 40212062, upload-time = "2026-02-05T07:02:12.724Z" },
 ]
 
+[[package]]
+name = "pillow"
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" },
+    { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" },
+    { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" },
+    { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" },
+    { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" },
+    { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.13.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d9/e4/40d09941a2cebcb20609b86a559817d5b9291c49dd6f8c87e5feffbe703a/pydantic-2.13.3.tar.gz", hash = "sha256:af09e9d1d09f4e7fe37145c1f577e1d61ceb9a41924bf0094a36506285d0a84d", size = 844068, upload-time = "2026-04-20T14:46:43.632Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/0a/fd7d723f8f8153418fb40cf9c940e82004fce7e987026b08a68a36dd3fe7/pydantic-2.13.3-py3-none-any.whl", hash = "sha256:6db14ac8dfc9a1e57f87ea2c0de670c251240f43cb0c30a5130e9720dc612927", size = 471981, upload-time = "2026-04-20T14:46:41.402Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.46.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/2a/ef/f7abb56c49382a246fd2ce9c799691e3c3e7175ec74b14d99e798bcddb1a/pydantic_core-2.46.3.tar.gz", hash = "sha256:41c178f65b8c29807239d47e6050262eb6bf84eb695e41101e62e38df4a5bc2c", size = 471412, upload-time = "2026-04-20T14:40:56.672Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/3c/9b5e8eb9821936d065439c3b0fb1490ffa64163bfe7e1595985a47896073/pydantic_core-2.46.3-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:12bc98de041458b80c86c56b24df1d23832f3e166cbaff011f25d187f5c62c37", size = 2102109, upload-time = "2026-04-20T14:41:24.219Z" },
+    { url = "https://files.pythonhosted.org/packages/91/97/1c41d1f5a19f241d8069f1e249853bcce378cdb76eec8ab636d7bc426280/pydantic_core-2.46.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:85348b8f89d2c3508b65b16c3c33a4da22b8215138d8b996912bb1532868885f", size = 1951820, upload-time = "2026-04-20T14:42:14.236Z" },
+    { url = "https://files.pythonhosted.org/packages/30/b4/d03a7ae14571bc2b6b3c7b122441154720619afe9a336fa3a95434df5e2f/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1105677a6df914b1fb71a81b96c8cce7726857e1717d86001f29be06a25ee6f8", size = 1977785, upload-time = "2026-04-20T14:42:31.648Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/0c/4086f808834b59e3c8f1aa26df8f4b6d998cdcf354a143d18ef41529d1fe/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:87082cd65669a33adeba5470769e9704c7cf026cc30afb9cc77fd865578ebaad", size = 2062761, upload-time = "2026-04-20T14:40:37.093Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/71/a649be5a5064c2df0db06e0a512c2281134ed2fcc981f52a657936a7527c/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60e5f66e12c4f5212d08522963380eaaeac5ebd795826cfd19b2dfb0c7a52b9c", size = 2232989, upload-time = "2026-04-20T14:42:59.254Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/84/7756e75763e810b3a710f4724441d1ecc5883b94aacb07ca71c5fb5cfb69/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b6cdf19bf84128d5e7c37e8a73a0c5c10d51103a650ac585d42dd6ae233f2b7f", size = 2303975, upload-time = "2026-04-20T14:41:32.287Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/35/68a762e0c1e31f35fa0dac733cbd9f5b118042853698de9509c8e5bf128b/pydantic_core-2.46.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:031bb17f4885a43773c8c763089499f242aee2ea85cf17154168775dccdecf35", size = 2095325, upload-time = "2026-04-20T14:42:47.685Z" },
+    { url = "https://files.pythonhosted.org/packages/77/bf/1bf8c9a8e91836c926eae5e3e51dce009bf495a60ca56060689d3df3f340/pydantic_core-2.46.3-cp313-cp313-manylinux_2_31_riscv64.whl", hash = "sha256:bcf2a8b2982a6673693eae7348ef3d8cf3979c1d63b54fca7c397a635cc68687", size = 2133368, upload-time = "2026-04-20T14:41:22.766Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/50/87d818d6bab915984995157ceb2380f5aac4e563dddbed6b56f0ed057aba/pydantic_core-2.46.3-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:28e8cf2f52d72ced402a137145923a762cbb5081e48b34312f7a0c8f55928ec3", size = 2173908, upload-time = "2026-04-20T14:42:52.044Z" },
+    { url = "https://files.pythonhosted.org/packages/91/88/a311fb306d0bd6185db41fa14ae888fb81d0baf648a761ae760d30819d33/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:17eaface65d9fc5abb940003020309c1bf7a211f5f608d7870297c367e6f9022", size = 2186422, upload-time = "2026-04-20T14:43:29.55Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/79/28fd0d81508525ab2054fef7c77a638c8b5b0afcbbaeee493cf7c3fef7e1/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:93fd339f23408a07e98950a89644f92c54d8729719a40b30c0a30bb9ebc55d23", size = 2332709, upload-time = "2026-04-20T14:42:16.134Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/21/795bf5fe5c0f379308b8ef19c50dedab2e7711dbc8d0c2acf08f1c7daa05/pydantic_core-2.46.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:23cbdb3aaa74dfe0837975dbf69b469753bbde8eacace524519ffdb6b6e89eb7", size = 2372428, upload-time = "2026-04-20T14:41:10.974Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b3/ed14c659cbe7605e3ef063077680a64680aec81eb1a04763a05190d49b7f/pydantic_core-2.46.3-cp313-cp313-win32.whl", hash = "sha256:610eda2e3838f401105e6326ca304f5da1e15393ae25dacae5c5c63f2c275b13", size = 1965601, upload-time = "2026-04-20T14:41:42.128Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/bb/adb70d9a762ddd002d723fbf1bd492244d37da41e3af7b74ad212609027e/pydantic_core-2.46.3-cp313-cp313-win_amd64.whl", hash = "sha256:68cc7866ed863db34351294187f9b729964c371ba33e31c26f478471c52e1ed0", size = 2071517, upload-time = "2026-04-20T14:43:36.096Z" },
+    { url = "https://files.pythonhosted.org/packages/52/eb/66faefabebfe68bd7788339c9c9127231e680b11906368c67ce112fdb47f/pydantic_core-2.46.3-cp313-cp313-win_arm64.whl", hash = "sha256:f64b5537ac62b231572879cd08ec05600308636a5d63bcbdb15063a466977bec", size = 2035802, upload-time = "2026-04-20T14:43:38.507Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/db/a7bcb4940183fda36022cd18ba8dd12f2dff40740ec7b58ce7457befa416/pydantic_core-2.46.3-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:afa3aa644f74e290cdede48a7b0bee37d1c35e71b05105f6b340d484af536d9b", size = 2097614, upload-time = "2026-04-20T14:44:38.374Z" },
+    { url = "https://files.pythonhosted.org/packages/24/35/e4066358a22e3e99519db370494c7528f5a2aa1367370e80e27e20283543/pydantic_core-2.46.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ced3310e51aa425f7f77da8bbbb5212616655bedbe82c70944320bc1dbe5e018", size = 1951896, upload-time = "2026-04-20T14:40:53.996Z" },
+    { url = "https://files.pythonhosted.org/packages/87/92/37cf4049d1636996e4b888c05a501f40a43ff218983a551d57f9d5e14f0d/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e29908922ce9da1a30b4da490bd1d3d82c01dcfdf864d2a74aacee674d0bfa34", size = 1979314, upload-time = "2026-04-20T14:41:49.446Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/36/9ff4d676dfbdfb2d591cf43f3d90ded01e15b1404fd101180ed2d62a2fd3/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0c9ff69140423eea8ed2d5477df3ba037f671f5e897d206d921bc9fdc39613e7", size = 2056133, upload-time = "2026-04-20T14:42:23.574Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/f0/405b442a4d7ba855b06eec8b2bf9c617d43b8432d099dfdc7bf999293495/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b675ab0a0d5b1c8fdb81195dc5bcefea3f3c240871cdd7ff9a2de8aa50772eb2", size = 2228726, upload-time = "2026-04-20T14:44:22.816Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/f8/65cd92dd5a0bd89ba277a98ecbfaf6fc36bbd3300973c7a4b826d6ab1391/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0087084960f209a9a4af50ecd1fb063d9ad3658c07bb81a7a53f452dacbfb2ba", size = 2301214, upload-time = "2026-04-20T14:44:48.792Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/86/ef96a4c6e79e7a2d0410826a68fbc0eccc0fd44aa733be199d5fcac3bb87/pydantic_core-2.46.3-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ed42e6cc8e1b0e2b9b96e2276bad70ae625d10d6d524aed0c93de974ae029f9f", size = 2099927, upload-time = "2026-04-20T14:41:40.196Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/53/269caf30e0096e0a8a8f929d1982a27b3879872cca2d917d17c2f9fdf4fe/pydantic_core-2.46.3-cp314-cp314-manylinux_2_31_riscv64.whl", hash = "sha256:f1771ce258afb3e4201e67d154edbbae712a76a6081079fe247c2f53c6322c22", size = 2128789, upload-time = "2026-04-20T14:41:15.868Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b0/1a6d9b6a587e118482910c244a1c5acf4d192604174132efd12bf0ac486f/pydantic_core-2.46.3-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a7610b6a5242a6c736d8ad47fd5fff87fcfe8f833b281b1c409c3d6835d9227f", size = 2173815, upload-time = "2026-04-20T14:44:25.152Z" },
+    { url = "https://files.pythonhosted.org/packages/87/56/e7e00d4041a7e62b5a40815590114db3b535bf3ca0bf4dca9f16cef25246/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:ff5e7783bcc5476e1db448bf268f11cb257b1c276d3e89f00b5727be86dd0127", size = 2181608, upload-time = "2026-04-20T14:41:28.933Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/22/4bd23c3d41f7c185d60808a1de83c76cf5aeabf792f6c636a55c3b1ec7f9/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:9d2e32edcc143bc01e95300671915d9ca052d4f745aa0a49c48d4803f8a85f2c", size = 2326968, upload-time = "2026-04-20T14:42:03.962Z" },
+    { url = "https://files.pythonhosted.org/packages/24/ac/66cd45129e3915e5ade3b292cb3bc7fd537f58f8f8dbdaba6170f7cabb74/pydantic_core-2.46.3-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6e42d83d1c6b87fa56b521479cff237e626a292f3b31b6345c15a99121b454c1", size = 2369842, upload-time = "2026-04-20T14:41:35.52Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/51/dd4248abb84113615473aa20d5545b7c4cd73c8644003b5259686f93996c/pydantic_core-2.46.3-cp314-cp314-win32.whl", hash = "sha256:07bc6d2a28c3adb4f7c6ae46aa4f2d2929af127f587ed44057af50bf1ce0f505", size = 1959661, upload-time = "2026-04-20T14:41:00.042Z" },
+    { url = "https://files.pythonhosted.org/packages/20/eb/59980e5f1ae54a3b86372bd9f0fa373ea2d402e8cdcd3459334430f91e91/pydantic_core-2.46.3-cp314-cp314-win_amd64.whl", hash = "sha256:8940562319bc621da30714617e6a7eaa6b98c84e8c685bcdc02d7ed5e7c7c44e", size = 2071686, upload-time = "2026-04-20T14:43:16.471Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/db/1cf77e5247047dfee34bc01fa9bca134854f528c8eb053e144298893d370/pydantic_core-2.46.3-cp314-cp314-win_arm64.whl", hash = "sha256:5dcbbcf4d22210ced8f837c96db941bdb078f419543472aca5d9a0bb7cddc7df", size = 2026907, upload-time = "2026-04-20T14:43:31.732Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c0/b3df9f6a543276eadba0a48487b082ca1f201745329d97dbfa287034a230/pydantic_core-2.46.3-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:d0fe3dce1e836e418f912c1ad91c73357d03e556a4d286f441bf34fed2dbeecf", size = 2095047, upload-time = "2026-04-20T14:42:37.982Z" },
+    { url = "https://files.pythonhosted.org/packages/66/57/886a938073b97556c168fd99e1a7305bb363cd30a6d2c76086bf0587b32a/pydantic_core-2.46.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:9ce92e58abc722dac1bf835a6798a60b294e48eb0e625ec9fd994b932ac5feee", size = 1934329, upload-time = "2026-04-20T14:43:49.655Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/7c/b42eaa5c34b13b07ecb51da21761297a9b8eb43044c864a035999998f328/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a03e6467f0f5ab796a486146d1b887b2dc5e5f9b3288898c1b1c3ad974e53e4a", size = 1974847, upload-time = "2026-04-20T14:42:10.737Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/9b/92b42db6543e7de4f99ae977101a2967b63122d4b6cf7773812da2d7d5b5/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2798b6ba041b9d70acfb9071a2ea13c8456dd1e6a5555798e41ba7b0790e329c", size = 2041742, upload-time = "2026-04-20T14:40:44.262Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/19/46fbe1efabb5aa2834b43b9454e70f9a83ad9c338c1291e48bdc4fecf167/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9be3e221bdc6d69abf294dcf7aff6af19c31a5cdcc8f0aa3b14be29df4bd03b1", size = 2236235, upload-time = "2026-04-20T14:41:27.307Z" },
+    { url = "https://files.pythonhosted.org/packages/77/da/b3f95bc009ad60ec53120f5d16c6faa8cabdbe8a20d83849a1f2b8728148/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f13936129ce841f2a5ddf6f126fea3c43cd128807b5a59588c37cf10178c2e64", size = 2282633, upload-time = "2026-04-20T14:44:33.271Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/6e/401336117722e28f32fb8220df676769d28ebdf08f2f4469646d404c43a3/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28b5f2ef03416facccb1c6ef744c69793175fd27e44ef15669201601cf423acb", size = 2109679, upload-time = "2026-04-20T14:44:41.065Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/53/b289f9bc8756a32fe718c46f55afaeaf8d489ee18d1a1e7be1db73f42cc4/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_31_riscv64.whl", hash = "sha256:830d1247d77ad23852314f069e9d7ddafeec5f684baf9d7e7065ed46a049c4e6", size = 2108342, upload-time = "2026-04-20T14:42:50.144Z" },
+    { url = "https://files.pythonhosted.org/packages/10/5b/8292fc7c1f9111f1b2b7c1b0dcf1179edcd014fc3ea4517499f50b829d71/pydantic_core-2.46.3-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d0793c90c1a3c74966e7975eaef3ed30ebdff3260a0f815a62a22adc17e4c01c", size = 2157208, upload-time = "2026-04-20T14:42:08.133Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/9e/f80044e9ec07580f057a89fc131f78dda7a58751ddf52bbe05eaf31db50f/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:d2d0aead851b66f5245ec0c4fb2612ef457f8bbafefdf65a2bf9d6bac6140f47", size = 2167237, upload-time = "2026-04-20T14:42:25.412Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/84/6781a1b037f3b96be9227edbd1101f6d3946746056231bf4ac48cdff1a8d/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_armv7l.whl", hash = "sha256:2f40e4246676beb31c5ce77c38a55ca4e465c6b38d11ea1bd935420568e0b1ab", size = 2312540, upload-time = "2026-04-20T14:40:40.313Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/db/19c0839feeb728e7df03255581f198dfdf1c2aeb1e174a8420b63c5252e5/pydantic_core-2.46.3-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:cf489cf8986c543939aeee17a09c04d6ffb43bfef8ca16fcbcc5cfdcbed24dba", size = 2369556, upload-time = "2026-04-20T14:41:09.427Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/15/3228774cb7cd45f5f721ddf1b2242747f4eb834d0c491f0c02d606f09fed/pydantic_core-2.46.3-cp314-cp314t-win32.whl", hash = "sha256:ffe0883b56cfc05798bf994164d2b2ff03efe2d22022a2bb080f3b626176dd56", size = 1949756, upload-time = "2026-04-20T14:41:25.717Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/2a/c79cf53fd91e5a87e30d481809f52f9a60dd221e39de66455cf04deaad37/pydantic_core-2.46.3-cp314-cp314t-win_amd64.whl", hash = "sha256:706d9d0ce9cf4593d07270d8e9f53b161f90c57d315aeec4fb4fd7a8b10240d8", size = 2051305, upload-time = "2026-04-20T14:43:18.627Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/db/d8182a7f1d9343a032265aae186eb063fe26ca4c40f256b21e8da4498e89/pydantic_core-2.46.3-cp314-cp314t-win_arm64.whl", hash = "sha256:77706aeb41df6a76568434701e0917da10692da28cb69d5fb6919ce5fdb07374", size = 2026310, upload-time = "2026-04-20T14:41:01.778Z" },
+]
+
+[[package]]
+name = "python-dotenv"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/82/ed/0301aeeac3e5353ef3d94b6ec08bbcabd04a72018415dcb29e588514bba8/python_dotenv-1.2.2.tar.gz", hash = "sha256:2c371a91fbd7ba082c2c1dc1f8bf89ca22564a087c2c287cd9b662adde799cf3", size = 50135, upload-time = "2026-03-01T16:00:26.196Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/d7/1959b9648791274998a9c3526f6d0ec8fd2233e4d4acce81bbae76b44b2a/python_dotenv-1.2.2-py3-none-any.whl", hash = "sha256:1d8214789a24de455a8b8bd8ae6fe3c6b69a5e3d64aa8a8e5d68e694bbcb285a", size = 22101, upload-time = "2026-03-01T16:00:25.09Z" },
+]
+
+[[package]]
+name = "python-multipart"
+version = "0.0.26"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/88/71/b145a380824a960ebd60e1014256dbb7d2253f2316ff2d73dfd8928ec2c3/python_multipart-0.0.26.tar.gz", hash = "sha256:08fadc45918cd615e26846437f50c5d6d23304da32c341f289a617127b081f17", size = 43501, upload-time = "2026-04-10T14:09:59.473Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9a/22/f1925cdda983ab66fc8ec6ec8014b959262747e58bdca26a4e3d1da29d56/python_multipart-0.0.26-py3-none-any.whl", hash = "sha256:c0b169f8c4484c13b0dcf2ef0ec3a4adb255c4b7d18d8e420477d2b1dd03f185", size = 28847, upload-time = "2026-04-10T14:09:58.131Z" },
+]
+
+[[package]]
+name = "pyyaml"
+version = "6.0.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/05/8e/961c0007c59b8dd7729d542c61a4d537767a59645b82a0b521206e1e25c2/pyyaml-6.0.3.tar.gz", hash = "sha256:d76623373421df22fb4cf8817020cbb7ef15c725b9d5e45f17e189bfc384190f", size = 130960, upload-time = "2025-09-25T21:33:16.546Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/11/0fd08f8192109f7169db964b5707a2f1e8b745d4e239b784a5a1dd80d1db/pyyaml-6.0.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8da9669d359f02c0b91ccc01cac4a67f16afec0dac22c2ad09f46bee0697eba8", size = 181669, upload-time = "2025-09-25T21:32:23.673Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/16/95309993f1d3748cd644e02e38b75d50cbc0d9561d21f390a76242ce073f/pyyaml-6.0.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:2283a07e2c21a2aa78d9c4442724ec1eb15f5e42a723b99cb3d822d48f5f7ad1", size = 173252, upload-time = "2025-09-25T21:32:25.149Z" },
+    { url = "https://files.pythonhosted.org/packages/50/31/b20f376d3f810b9b2371e72ef5adb33879b25edb7a6d072cb7ca0c486398/pyyaml-6.0.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ee2922902c45ae8ccada2c5b501ab86c36525b883eff4255313a253a3160861c", size = 767081, upload-time = "2025-09-25T21:32:26.575Z" },
+    { url = "https://files.pythonhosted.org/packages/49/1e/a55ca81e949270d5d4432fbbd19dfea5321eda7c41a849d443dc92fd1ff7/pyyaml-6.0.3-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a33284e20b78bd4a18c8c2282d549d10bc8408a2a7ff57653c0cf0b9be0afce5", size = 841159, upload-time = "2025-09-25T21:32:27.727Z" },
+    { url = "https://files.pythonhosted.org/packages/74/27/e5b8f34d02d9995b80abcef563ea1f8b56d20134d8f4e5e81733b1feceb2/pyyaml-6.0.3-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0f29edc409a6392443abf94b9cf89ce99889a1dd5376d94316ae5145dfedd5d6", size = 801626, upload-time = "2025-09-25T21:32:28.878Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/11/ba845c23988798f40e52ba45f34849aa8a1f2d4af4b798588010792ebad6/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f7057c9a337546edc7973c0d3ba84ddcdf0daa14533c2065749c9075001090e6", size = 753613, upload-time = "2025-09-25T21:32:30.178Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/e0/7966e1a7bfc0a45bf0a7fb6b98ea03fc9b8d84fa7f2229e9659680b69ee3/pyyaml-6.0.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eda16858a3cab07b80edaf74336ece1f986ba330fdb8ee0d6c0d68fe82bc96be", size = 794115, upload-time = "2025-09-25T21:32:31.353Z" },
+    { url = "https://files.pythonhosted.org/packages/de/94/980b50a6531b3019e45ddeada0626d45fa85cbe22300844a7983285bed3b/pyyaml-6.0.3-cp313-cp313-win32.whl", hash = "sha256:d0eae10f8159e8fdad514efdc92d74fd8d682c933a6dd088030f3834bc8e6b26", size = 137427, upload-time = "2025-09-25T21:32:32.58Z" },
+    { url = "https://files.pythonhosted.org/packages/97/c9/39d5b874e8b28845e4ec2202b5da735d0199dbe5b8fb85f91398814a9a46/pyyaml-6.0.3-cp313-cp313-win_amd64.whl", hash = "sha256:79005a0d97d5ddabfeeea4cf676af11e647e41d81c9a7722a193022accdb6b7c", size = 154090, upload-time = "2025-09-25T21:32:33.659Z" },
+    { url = "https://files.pythonhosted.org/packages/73/e8/2bdf3ca2090f68bb3d75b44da7bbc71843b19c9f2b9cb9b0f4ab7a5a4329/pyyaml-6.0.3-cp313-cp313-win_arm64.whl", hash = "sha256:5498cd1645aa724a7c71c8f378eb29ebe23da2fc0d7a08071d89469bf1d2defb", size = 140246, upload-time = "2025-09-25T21:32:34.663Z" },
+    { url = "https://files.pythonhosted.org/packages/9d/8c/f4bd7f6465179953d3ac9bc44ac1a8a3e6122cf8ada906b4f96c60172d43/pyyaml-6.0.3-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:8d1fab6bb153a416f9aeb4b8763bc0f22a5586065f86f7664fc23339fc1c1fac", size = 181814, upload-time = "2025-09-25T21:32:35.712Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/9c/4d95bb87eb2063d20db7b60faa3840c1b18025517ae857371c4dd55a6b3a/pyyaml-6.0.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:34d5fcd24b8445fadc33f9cf348c1047101756fd760b4dacb5c3e99755703310", size = 173809, upload-time = "2025-09-25T21:32:36.789Z" },
+    { url = "https://files.pythonhosted.org/packages/92/b5/47e807c2623074914e29dabd16cbbdd4bf5e9b2db9f8090fa64411fc5382/pyyaml-6.0.3-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:501a031947e3a9025ed4405a168e6ef5ae3126c59f90ce0cd6f2bfc477be31b7", size = 766454, upload-time = "2025-09-25T21:32:37.966Z" },
+    { url = "https://files.pythonhosted.org/packages/02/9e/e5e9b168be58564121efb3de6859c452fccde0ab093d8438905899a3a483/pyyaml-6.0.3-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:b3bc83488de33889877a0f2543ade9f70c67d66d9ebb4ac959502e12de895788", size = 836355, upload-time = "2025-09-25T21:32:39.178Z" },
+    { url = "https://files.pythonhosted.org/packages/88/f9/16491d7ed2a919954993e48aa941b200f38040928474c9e85ea9e64222c3/pyyaml-6.0.3-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c458b6d084f9b935061bc36216e8a69a7e293a2f1e68bf956dcd9e6cbcd143f5", size = 794175, upload-time = "2025-09-25T21:32:40.865Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/3f/5989debef34dc6397317802b527dbbafb2b4760878a53d4166579111411e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7c6610def4f163542a622a73fb39f534f8c101d690126992300bf3207eab9764", size = 755228, upload-time = "2025-09-25T21:32:42.084Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/ce/af88a49043cd2e265be63d083fc75b27b6ed062f5f9fd6cdc223ad62f03e/pyyaml-6.0.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5190d403f121660ce8d1d2c1bb2ef1bd05b5f68533fc5c2ea899bd15f4399b35", size = 789194, upload-time = "2025-09-25T21:32:43.362Z" },
+    { url = "https://files.pythonhosted.org/packages/23/20/bb6982b26a40bb43951265ba29d4c246ef0ff59c9fdcdf0ed04e0687de4d/pyyaml-6.0.3-cp314-cp314-win_amd64.whl", hash = "sha256:4a2e8cebe2ff6ab7d1050ecd59c25d4c8bd7e6f400f5f82b96557ac0abafd0ac", size = 156429, upload-time = "2025-09-25T21:32:57.844Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/f4/a4541072bb9422c8a883ab55255f918fa378ecf083f5b85e87fc2b4eda1b/pyyaml-6.0.3-cp314-cp314-win_arm64.whl", hash = "sha256:93dda82c9c22deb0a405ea4dc5f2d0cda384168e466364dec6255b293923b2f3", size = 143912, upload-time = "2025-09-25T21:32:59.247Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/f9/07dd09ae774e4616edf6cda684ee78f97777bdd15847253637a6f052a62f/pyyaml-6.0.3-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:02893d100e99e03eda1c8fd5c441d8c60103fd175728e23e431db1b589cf5ab3", size = 189108, upload-time = "2025-09-25T21:32:44.377Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/78/8d08c9fb7ce09ad8c38ad533c1191cf27f7ae1effe5bb9400a46d9437fcf/pyyaml-6.0.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:c1ff362665ae507275af2853520967820d9124984e0f7466736aea23d8611fba", size = 183641, upload-time = "2025-09-25T21:32:45.407Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5b/3babb19104a46945cf816d047db2788bcaf8c94527a805610b0289a01c6b/pyyaml-6.0.3-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6adc77889b628398debc7b65c073bcb99c4a0237b248cacaf3fe8a557563ef6c", size = 831901, upload-time = "2025-09-25T21:32:48.83Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cc/dff0684d8dc44da4d22a13f35f073d558c268780ce3c6ba1b87055bb0b87/pyyaml-6.0.3-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a80cb027f6b349846a3bf6d73b5e95e782175e52f22108cfa17876aaeff93702", size = 861132, upload-time = "2025-09-25T21:32:50.149Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/5e/f77dc6b9036943e285ba76b49e118d9ea929885becb0a29ba8a7c75e29fe/pyyaml-6.0.3-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:00c4bdeba853cc34e7dd471f16b4114f4162dc03e6b7afcc2128711f0eca823c", size = 839261, upload-time = "2025-09-25T21:32:51.808Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/88/a9db1376aa2a228197c58b37302f284b5617f56a5d959fd1763fb1675ce6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:66e1674c3ef6f541c35191caae2d429b967b99e02040f5ba928632d9a7f0f065", size = 805272, upload-time = "2025-09-25T21:32:52.941Z" },
+    { url = "https://files.pythonhosted.org/packages/da/92/1446574745d74df0c92e6aa4a7b0b3130706a4142b2d1a5869f2eaa423c6/pyyaml-6.0.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:16249ee61e95f858e83976573de0f5b2893b3677ba71c9dd36b9cf8be9ac6d65", size = 829923, upload-time = "2025-09-25T21:32:54.537Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/1c7270340330e575b92f397352af856a8c06f230aa3e76f86b39d01b416a/pyyaml-6.0.3-cp314-cp314t-win_amd64.whl", hash = "sha256:4ad1906908f2f5ae4e5a8ddfce73c320c2a1429ec52eafd27138b7f1cbe341c9", size = 174062, upload-time = "2025-09-25T21:32:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/12/de94a39c2ef588c7e6455cfbe7343d3b2dc9d6b6b2f40c4c6565744c873d/pyyaml-6.0.3-cp314-cp314t-win_arm64.whl", hash = "sha256:ebc55a14a21cb14062aa4162f906cd962b28e2e9ea38f9b4391244cd8de4ae0b", size = 149341, upload-time = "2025-09-25T21:32:56.828Z" },
+]
+
 [[package]]
 name = "shape-model-2d"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "fastapi" },
     { name = "numba" },
     { name = "numpy" },
     { name = "opencv-python" },
+    { name = "pillow" },
+    { name = "python-multipart" },
+    { name = "uvicorn", extra = ["standard"] },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "httpx" },
 ]
 
 [package.metadata]
 requires-dist = [
+    { name = "fastapi", specifier = ">=0.115" },
     { name = "numba", specifier = ">=0.65.0" },
     { name = "numpy", specifier = ">=1.24" },
     { name = "opencv-python", specifier = ">=4.8" },
+    { name = "pillow", specifier = ">=12.2.0" },
+    { name = "python-multipart", specifier = ">=0.0.26" },
+    { name = "uvicorn", extras = ["standard"], specifier = ">=0.34" },
+]
+
+[package.metadata.requires-dev]
+dev = [{ name = "httpx", specifier = ">=0.28.1" }]
+
+[[package]]
+name = "starlette"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/17425771797c36cded50b7fe44e850315d039f28b15901ab44839e70b593/starlette-1.0.0.tar.gz", hash = "sha256:6a4beaf1f81bb472fd19ea9b918b50dc3a77a6f2e190a12954b25e6ed5eea149", size = 2655289, upload-time = "2026-03-22T18:29:46.779Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0b/c9/584bc9651441b4ba60cc4d557d8a547b5aff901af35bda3a4ee30c819b82/starlette-1.0.0-py3-none-any.whl", hash = "sha256:d3ec55e0bb321692d275455ddfd3df75fff145d009685eb40dc91fc66b03d38b", size = 72651, upload-time = "2026-03-22T18:29:45.111Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "uvicorn"
+version = "0.46.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/1f/93/041fca8274050e40e6791f267d82e0e2e27dd165627bd640d3e0e378d877/uvicorn-0.46.0.tar.gz", hash = "sha256:fb9da0926999cc6cb22dc7cd71a94a632f078e6ae47ff683c5c420750fb7413d", size = 88758, upload-time = "2026-04-23T07:16:00.151Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/31/a3/5b1562db76a5a488274b2332a97199b32d0442aca0ed193697fd47786316/uvicorn-0.46.0-py3-none-any.whl", hash = "sha256:bbebbcbed972d162afca128605223022bedd345b7bc7855ce66deb31487a9048", size = 70926, upload-time = "2026-04-23T07:15:58.355Z" },
+]
+
+[package.optional-dependencies]
+standard = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "httptools" },
+    { name = "python-dotenv" },
+    { name = "pyyaml" },
+    { name = "uvloop", marker = "platform_python_implementation != 'PyPy' and sys_platform != 'cygwin' and sys_platform != 'win32'" },
+    { name = "watchfiles" },
+    { name = "websockets" },
+]
+
+[[package]]
+name = "uvloop"
+version = "0.22.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/06/f0/18d39dbd1971d6d62c4629cc7fa67f74821b0dc1f5a77af43719de7936a7/uvloop-0.22.1.tar.gz", hash = "sha256:6c84bae345b9147082b17371e3dd5d42775bddce91f885499017f4607fdaf39f", size = 2443250, upload-time = "2025-10-16T22:17:19.342Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/8c/182a2a593195bfd39842ea68ebc084e20c850806117213f5a299dfc513d9/uvloop-0.22.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:561577354eb94200d75aca23fbde86ee11be36b00e52a4eaf8f50fb0c86b7705", size = 1358611, upload-time = "2025-10-16T22:16:36.833Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/14/e301ee96a6dc95224b6f1162cd3312f6d1217be3907b79173b06785f2fe7/uvloop-0.22.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cdf5192ab3e674ca26da2eada35b288d2fa49fdd0f357a19f0e7c4e7d5077c8", size = 751811, upload-time = "2025-10-16T22:16:38.275Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/02/654426ce265ac19e2980bfd9ea6590ca96a56f10c76e63801a2df01c0486/uvloop-0.22.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6e2ea3d6190a2968f4a14a23019d3b16870dd2190cd69c8180f7c632d21de68d", size = 4288562, upload-time = "2025-10-16T22:16:39.375Z" },
+    { url = "https://files.pythonhosted.org/packages/15/c0/0be24758891ef825f2065cd5db8741aaddabe3e248ee6acc5e8a80f04005/uvloop-0.22.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0530a5fbad9c9e4ee3f2b33b148c6a64d47bbad8000ea63704fa8260f4cf728e", size = 4366890, upload-time = "2025-10-16T22:16:40.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/53/8369e5219a5855869bcee5f4d317f6da0e2c669aecf0ef7d371e3d084449/uvloop-0.22.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bc5ef13bbc10b5335792360623cc378d52d7e62c2de64660616478c32cd0598e", size = 4119472, upload-time = "2025-10-16T22:16:41.694Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/ba/d69adbe699b768f6b29a5eec7b47dd610bd17a69de51b251126a801369ea/uvloop-0.22.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1f38ec5e3f18c8a10ded09742f7fb8de0108796eb673f30ce7762ce1b8550cad", size = 4239051, upload-time = "2025-10-16T22:16:43.224Z" },
+    { url = "https://files.pythonhosted.org/packages/90/cd/b62bdeaa429758aee8de8b00ac0dd26593a9de93d302bff3d21439e9791d/uvloop-0.22.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3879b88423ec7e97cd4eba2a443aa26ed4e59b45e6b76aabf13fe2f27023a142", size = 1362067, upload-time = "2025-10-16T22:16:44.503Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/f8/a132124dfda0777e489ca86732e85e69afcd1ff7686647000050ba670689/uvloop-0.22.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:4baa86acedf1d62115c1dc6ad1e17134476688f08c6efd8a2ab076e815665c74", size = 752423, upload-time = "2025-10-16T22:16:45.968Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/94/94af78c156f88da4b3a733773ad5ba0b164393e357cc4bd0ab2e2677a7d6/uvloop-0.22.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:297c27d8003520596236bdb2335e6b3f649480bd09e00d1e3a99144b691d2a35", size = 4272437, upload-time = "2025-10-16T22:16:47.451Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/35/60249e9fd07b32c665192cec7af29e06c7cd96fa1d08b84f012a56a0b38e/uvloop-0.22.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c1955d5a1dd43198244d47664a5858082a3239766a839b2102a269aaff7a4e25", size = 4292101, upload-time = "2025-10-16T22:16:49.318Z" },
+    { url = "https://files.pythonhosted.org/packages/02/62/67d382dfcb25d0a98ce73c11ed1a6fba5037a1a1d533dcbb7cab033a2636/uvloop-0.22.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b31dc2fccbd42adc73bc4e7cdbae4fc5086cf378979e53ca5d0301838c5682c6", size = 4114158, upload-time = "2025-10-16T22:16:50.517Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/7a/f1171b4a882a5d13c8b7576f348acfe6074d72eaf52cccef752f748d4a9f/uvloop-0.22.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:93f617675b2d03af4e72a5333ef89450dfaa5321303ede6e67ba9c9d26878079", size = 4177360, upload-time = "2025-10-16T22:16:52.646Z" },
+    { url = "https://files.pythonhosted.org/packages/79/7b/b01414f31546caf0919da80ad57cbfe24c56b151d12af68cee1b04922ca8/uvloop-0.22.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:37554f70528f60cad66945b885eb01f1bb514f132d92b6eeed1c90fd54ed6289", size = 1454790, upload-time = "2025-10-16T22:16:54.355Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/31/0bb232318dd838cad3fa8fb0c68c8b40e1145b32025581975e18b11fab40/uvloop-0.22.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:b76324e2dc033a0b2f435f33eb88ff9913c156ef78e153fb210e03c13da746b3", size = 796783, upload-time = "2025-10-16T22:16:55.906Z" },
+    { url = "https://files.pythonhosted.org/packages/42/38/c9b09f3271a7a723a5de69f8e237ab8e7803183131bc57c890db0b6bb872/uvloop-0.22.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:badb4d8e58ee08dad957002027830d5c3b06aea446a6a3744483c2b3b745345c", size = 4647548, upload-time = "2025-10-16T22:16:57.008Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/37/945b4ca0ac27e3dc4952642d4c900edd030b3da6c9634875af6e13ae80e5/uvloop-0.22.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b91328c72635f6f9e0282e4a57da7470c7350ab1c9f48546c0f2866205349d21", size = 4467065, upload-time = "2025-10-16T22:16:58.206Z" },
+    { url = "https://files.pythonhosted.org/packages/97/cc/48d232f33d60e2e2e0b42f4e73455b146b76ebe216487e862700457fbf3c/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:daf620c2995d193449393d6c62131b3fbd40a63bf7b307a1527856ace637fe88", size = 4328384, upload-time = "2025-10-16T22:16:59.36Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/16/c1fd27e9549f3c4baf1dc9c20c456cd2f822dbf8de9f463824b0c0357e06/uvloop-0.22.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:6cde23eeda1a25c75b2e07d39970f3374105d5eafbaab2a4482be82f272d5a5e", size = 4296730, upload-time = "2025-10-16T22:17:00.744Z" },
+]
+
+[[package]]
+name = "watchfiles"
+version = "1.1.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8869df9b2a2d6c59d79220a4db37679e74f807c559ffe5265e08b227a210/watchfiles-1.1.1.tar.gz", hash = "sha256:a173cb5c16c4f40ab19cecf48a534c409f7ea983ab8fed0741304a1c0a31b3f2", size = 94440, upload-time = "2025-10-14T15:06:21.08Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bb/f4/f750b29225fe77139f7ae5de89d4949f5a99f934c65a1f1c0b248f26f747/watchfiles-1.1.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:130e4876309e8686a5e37dba7d5e9bc77e6ed908266996ca26572437a5271e18", size = 404321, upload-time = "2025-10-14T15:05:02.063Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/f9/f07a295cde762644aa4c4bb0f88921d2d141af45e735b965fb2e87858328/watchfiles-1.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5f3bde70f157f84ece3765b42b4a52c6ac1a50334903c6eaf765362f6ccca88a", size = 391783, upload-time = "2025-10-14T15:05:03.052Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/11/fc2502457e0bea39a5c958d86d2cb69e407a4d00b85735ca724bfa6e0d1a/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:14e0b1fe858430fc0251737ef3824c54027bedb8c37c38114488b8e131cf8219", size = 449279, upload-time = "2025-10-14T15:05:04.004Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/1f/d66bc15ea0b728df3ed96a539c777acfcad0eb78555ad9efcaa1274688f0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:f27db948078f3823a6bb3b465180db8ebecf26dd5dae6f6180bd87383b6b4428", size = 459405, upload-time = "2025-10-14T15:05:04.942Z" },
+    { url = "https://files.pythonhosted.org/packages/be/90/9f4a65c0aec3ccf032703e6db02d89a157462fbb2cf20dd415128251cac0/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:059098c3a429f62fc98e8ec62b982230ef2c8df68c79e826e37b895bc359a9c0", size = 488976, upload-time = "2025-10-14T15:05:05.905Z" },
+    { url = "https://files.pythonhosted.org/packages/37/57/ee347af605d867f712be7029bb94c8c071732a4b44792e3176fa3c612d39/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfb5862016acc9b869bb57284e6cb35fdf8e22fe59f7548858e2f971d045f150", size = 595506, upload-time = "2025-10-14T15:05:06.906Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/78/cc5ab0b86c122047f75e8fc471c67a04dee395daf847d3e59381996c8707/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:319b27255aacd9923b8a276bb14d21a5f7ff82564c744235fc5eae58d95422ae", size = 474936, upload-time = "2025-10-14T15:05:07.906Z" },
+    { url = "https://files.pythonhosted.org/packages/62/da/def65b170a3815af7bd40a3e7010bf6ab53089ef1b75d05dd5385b87cf08/watchfiles-1.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c755367e51db90e75b19454b680903631d41f9e3607fbd941d296a020c2d752d", size = 456147, upload-time = "2025-10-14T15:05:09.138Z" },
+    { url = "https://files.pythonhosted.org/packages/57/99/da6573ba71166e82d288d4df0839128004c67d2778d3b566c138695f5c0b/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:c22c776292a23bfc7237a98f791b9ad3144b02116ff10d820829ce62dff46d0b", size = 630007, upload-time = "2025-10-14T15:05:10.117Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/51/7439c4dd39511368849eb1e53279cd3454b4a4dbace80bab88feeb83c6b5/watchfiles-1.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:3a476189be23c3686bc2f4321dd501cb329c0a0469e77b7b534ee10129ae6374", size = 622280, upload-time = "2025-10-14T15:05:11.146Z" },
+    { url = "https://files.pythonhosted.org/packages/95/9c/8ed97d4bba5db6fdcdb2b298d3898f2dd5c20f6b73aee04eabe56c59677e/watchfiles-1.1.1-cp313-cp313-win32.whl", hash = "sha256:bf0a91bfb5574a2f7fc223cf95eeea79abfefa404bf1ea5e339c0c1560ae99a0", size = 272056, upload-time = "2025-10-14T15:05:12.156Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/f3/c14e28429f744a260d8ceae18bf58c1d5fa56b50d006a7a9f80e1882cb0d/watchfiles-1.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:52e06553899e11e8074503c8e716d574adeeb7e68913115c4b3653c53f9bae42", size = 288162, upload-time = "2025-10-14T15:05:13.208Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/61/fe0e56c40d5cd29523e398d31153218718c5786b5e636d9ae8ae79453d27/watchfiles-1.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:ac3cc5759570cd02662b15fbcd9d917f7ecd47efe0d6b40474eafd246f91ea18", size = 277909, upload-time = "2025-10-14T15:05:14.49Z" },
+    { url = "https://files.pythonhosted.org/packages/79/42/e0a7d749626f1e28c7108a99fb9bf524b501bbbeb9b261ceecde644d5a07/watchfiles-1.1.1-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:563b116874a9a7ce6f96f87cd0b94f7faf92d08d0021e837796f0a14318ef8da", size = 403389, upload-time = "2025-10-14T15:05:15.777Z" },
+    { url = "https://files.pythonhosted.org/packages/15/49/08732f90ce0fbbc13913f9f215c689cfc9ced345fb1bcd8829a50007cc8d/watchfiles-1.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3ad9fe1dae4ab4212d8c91e80b832425e24f421703b5a42ef2e4a1e215aff051", size = 389964, upload-time = "2025-10-14T15:05:16.85Z" },
+    { url = "https://files.pythonhosted.org/packages/27/0d/7c315d4bd5f2538910491a0393c56bf70d333d51bc5b34bee8e68e8cea19/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce70f96a46b894b36eba678f153f052967a0d06d5b5a19b336ab0dbbd029f73e", size = 448114, upload-time = "2025-10-14T15:05:17.876Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/24/9e096de47a4d11bc4df41e9d1e61776393eac4cb6eb11b3e23315b78b2cc/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cb467c999c2eff23a6417e58d75e5828716f42ed8289fe6b77a7e5a91036ca70", size = 460264, upload-time = "2025-10-14T15:05:18.962Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/0f/e8dea6375f1d3ba5fcb0b3583e2b493e77379834c74fd5a22d66d85d6540/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:836398932192dae4146c8f6f737d74baeac8b70ce14831a239bdb1ca882fc261", size = 487877, upload-time = "2025-10-14T15:05:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/5b/df24cfc6424a12deb41503b64d42fbea6b8cb357ec62ca84a5a3476f654a/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:743185e7372b7bc7c389e1badcc606931a827112fbbd37f14c537320fca08620", size = 595176, upload-time = "2025-10-14T15:05:21.134Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/b5/853b6757f7347de4e9b37e8cc3289283fb983cba1ab4d2d7144694871d9c/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:afaeff7696e0ad9f02cbb8f56365ff4686ab205fcf9c4c5b6fdfaaa16549dd04", size = 473577, upload-time = "2025-10-14T15:05:22.306Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/f7/0a4467be0a56e80447c8529c9fce5b38eab4f513cb3d9bf82e7392a5696b/watchfiles-1.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7eb7da0eb23aa2ba036d4f616d46906013a68caf61b7fdbe42fc8b25132e77", size = 455425, upload-time = "2025-10-14T15:05:23.348Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e0/82583485ea00137ddf69bc84a2db88bd92ab4a6e3c405e5fb878ead8d0e7/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:831a62658609f0e5c64178211c942ace999517f5770fe9436be4c2faeba0c0ef", size = 628826, upload-time = "2025-10-14T15:05:24.398Z" },
+    { url = "https://files.pythonhosted.org/packages/28/9a/a785356fccf9fae84c0cc90570f11702ae9571036fb25932f1242c82191c/watchfiles-1.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:f9a2ae5c91cecc9edd47e041a930490c31c3afb1f5e6d71de3dc671bfaca02bf", size = 622208, upload-time = "2025-10-14T15:05:25.45Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/f4/0872229324ef69b2c3edec35e84bd57a1289e7d3fe74588048ed8947a323/watchfiles-1.1.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:d1715143123baeeaeadec0528bb7441103979a1d5f6fd0e1f915383fea7ea6d5", size = 404315, upload-time = "2025-10-14T15:05:26.501Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/22/16d5331eaed1cb107b873f6ae1b69e9ced582fcf0c59a50cd84f403b1c32/watchfiles-1.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:39574d6370c4579d7f5d0ad940ce5b20db0e4117444e39b6d8f99db5676c52fd", size = 390869, upload-time = "2025-10-14T15:05:27.649Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/7e/5643bfff5acb6539b18483128fdc0ef2cccc94a5b8fbda130c823e8ed636/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7365b92c2e69ee952902e8f70f3ba6360d0d596d9299d55d7d386df84b6941fb", size = 449919, upload-time = "2025-10-14T15:05:28.701Z" },
+    { url = "https://files.pythonhosted.org/packages/51/2e/c410993ba5025a9f9357c376f48976ef0e1b1aefb73b97a5ae01a5972755/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bfff9740c69c0e4ed32416f013f3c45e2ae42ccedd1167ef2d805c000b6c71a5", size = 460845, upload-time = "2025-10-14T15:05:30.064Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/a4/2df3b404469122e8680f0fcd06079317e48db58a2da2950fb45020947734/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b27cf2eb1dda37b2089e3907d8ea92922b673c0c427886d4edc6b94d8dfe5db3", size = 489027, upload-time = "2025-10-14T15:05:31.064Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/84/4587ba5b1f267167ee715b7f66e6382cca6938e0a4b870adad93e44747e6/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:526e86aced14a65a5b0ec50827c745597c782ff46b571dbfe46192ab9e0b3c33", size = 595615, upload-time = "2025-10-14T15:05:32.074Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/0f/c6988c91d06e93cd0bb3d4a808bcf32375ca1904609835c3031799e3ecae/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:04e78dd0b6352db95507fd8cb46f39d185cf8c74e4cf1e4fbad1d3df96faf510", size = 474836, upload-time = "2025-10-14T15:05:33.209Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/36/ded8aebea91919485b7bbabbd14f5f359326cb5ec218cd67074d1e426d74/watchfiles-1.1.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5c85794a4cfa094714fb9c08d4a218375b2b95b8ed1666e8677c349906246c05", size = 455099, upload-time = "2025-10-14T15:05:34.189Z" },
+    { url = "https://files.pythonhosted.org/packages/98/e0/8c9bdba88af756a2fce230dd365fab2baf927ba42cd47521ee7498fd5211/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:74d5012b7630714b66be7b7b7a78855ef7ad58e8650c73afc4c076a1f480a8d6", size = 630626, upload-time = "2025-10-14T15:05:35.216Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/84/a95db05354bf2d19e438520d92a8ca475e578c647f78f53197f5a2f17aaf/watchfiles-1.1.1-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:8fbe85cb3201c7d380d3d0b90e63d520f15d6afe217165d7f98c9c649654db81", size = 622519, upload-time = "2025-10-14T15:05:36.259Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/ce/d8acdc8de545de995c339be67711e474c77d643555a9bb74a9334252bd55/watchfiles-1.1.1-cp314-cp314-win32.whl", hash = "sha256:3fa0b59c92278b5a7800d3ee7733da9d096d4aabcfabb9a928918bd276ef9b9b", size = 272078, upload-time = "2025-10-14T15:05:37.63Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/c9/a74487f72d0451524be827e8edec251da0cc1fcf111646a511ae752e1a3d/watchfiles-1.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:c2047d0b6cea13b3316bdbafbfa0c4228ae593d995030fda39089d36e64fc03a", size = 287664, upload-time = "2025-10-14T15:05:38.95Z" },
+    { url = "https://files.pythonhosted.org/packages/df/b8/8ac000702cdd496cdce998c6f4ee0ca1f15977bba51bdf07d872ebdfc34c/watchfiles-1.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:842178b126593addc05acf6fce960d28bc5fae7afbaa2c6c1b3a7b9460e5be02", size = 277154, upload-time = "2025-10-14T15:05:39.954Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a8/e3af2184707c29f0f14b1963c0aace6529f9d1b8582d5b99f31bbf42f59e/watchfiles-1.1.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:88863fbbc1a7312972f1c511f202eb30866370ebb8493aef2812b9ff28156a21", size = 403820, upload-time = "2025-10-14T15:05:40.932Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/e47e307c2f4bd75f9f9e8afbe3876679b18e1bcec449beca132a1c5ffb2d/watchfiles-1.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:55c7475190662e202c08c6c0f4d9e345a29367438cf8e8037f3155e10a88d5a5", size = 390510, upload-time = "2025-10-14T15:05:41.945Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/a0/ad235642118090f66e7b2f18fd5c42082418404a79205cdfca50b6309c13/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f53fa183d53a1d7a8852277c92b967ae99c2d4dcee2bfacff8868e6e30b15f7", size = 448408, upload-time = "2025-10-14T15:05:43.385Z" },
+    { url = "https://files.pythonhosted.org/packages/df/85/97fa10fd5ff3332ae17e7e40e20784e419e28521549780869f1413742e9d/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6aae418a8b323732fa89721d86f39ec8f092fc2af67f4217a2b07fd3e93c6101", size = 458968, upload-time = "2025-10-14T15:05:44.404Z" },
+    { url = "https://files.pythonhosted.org/packages/47/c2/9059c2e8966ea5ce678166617a7f75ecba6164375f3b288e50a40dc6d489/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f096076119da54a6080e8920cbdaac3dbee667eb91dcc5e5b78840b87415bd44", size = 488096, upload-time = "2025-10-14T15:05:45.398Z" },
+    { url = "https://files.pythonhosted.org/packages/94/44/d90a9ec8ac309bc26db808a13e7bfc0e4e78b6fc051078a554e132e80160/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00485f441d183717038ed2e887a7c868154f216877653121068107b227a2f64c", size = 596040, upload-time = "2025-10-14T15:05:46.502Z" },
+    { url = "https://files.pythonhosted.org/packages/95/68/4e3479b20ca305cfc561db3ed207a8a1c745ee32bf24f2026a129d0ddb6e/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a55f3e9e493158d7bfdb60a1165035f1cf7d320914e7b7ea83fe22c6023b58fc", size = 473847, upload-time = "2025-10-14T15:05:47.484Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/55/2af26693fd15165c4ff7857e38330e1b61ab8c37d15dc79118cdba115b7a/watchfiles-1.1.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c91ed27800188c2ae96d16e3149f199d62f86c7af5f5f4d2c61a3ed8cd3666c", size = 455072, upload-time = "2025-10-14T15:05:48.928Z" },
+    { url = "https://files.pythonhosted.org/packages/66/1d/d0d200b10c9311ec25d2273f8aad8c3ef7cc7ea11808022501811208a750/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_aarch64.whl", hash = "sha256:311ff15a0bae3714ffb603e6ba6dbfba4065ab60865d15a6ec544133bdb21099", size = 629104, upload-time = "2025-10-14T15:05:49.908Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/bd/fa9bb053192491b3867ba07d2343d9f2252e00811567d30ae8d0f78136fe/watchfiles-1.1.1-cp314-cp314t-musllinux_1_1_x86_64.whl", hash = "sha256:a916a2932da8f8ab582f242c065f5c81bed3462849ca79ee357dd9551b0e9b01", size = 622112, upload-time = "2025-10-14T15:05:50.941Z" },
+]
+
+[[package]]
+name = "websockets"
+version = "16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/04/24/4b2031d72e840ce4c1ccb255f693b15c334757fc50023e4db9537080b8c4/websockets-16.0.tar.gz", hash = "sha256:5f6261a5e56e8d5c42a4497b364ea24d94d9563e8fbd44e78ac40879c60179b5", size = 179346, upload-time = "2026-01-10T09:23:47.181Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/9c/baa8456050d1c1b08dd0ec7346026668cbc6f145ab4e314d707bb845bf0d/websockets-16.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:878b336ac47938b474c8f982ac2f7266a540adc3fa4ad74ae96fea9823a02cc9", size = 177364, upload-time = "2026-01-10T09:22:59.333Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/0c/8811fc53e9bcff68fe7de2bcbe75116a8d959ac699a3200f4847a8925210/websockets-16.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:52a0fec0e6c8d9a784c2c78276a48a2bdf099e4ccc2a4cad53b27718dbfd0230", size = 175039, upload-time = "2026-01-10T09:23:01.171Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/82/39a5f910cb99ec0b59e482971238c845af9220d3ab9fa76dd9162cda9d62/websockets-16.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e6578ed5b6981005df1860a56e3617f14a6c307e6a71b4fff8c48fdc50f3ed2c", size = 175323, upload-time = "2026-01-10T09:23:02.341Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/28/0a25ee5342eb5d5f297d992a77e56892ecb65e7854c7898fb7d35e9b33bd/websockets-16.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:95724e638f0f9c350bb1c2b0a7ad0e83d9cc0c9259f3ea94e40d7b02a2179ae5", size = 184975, upload-time = "2026-01-10T09:23:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/66/27ea52741752f5107c2e41fda05e8395a682a1e11c4e592a809a90c6a506/websockets-16.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c0204dc62a89dc9d50d682412c10b3542d748260d743500a85c13cd1ee4bde82", size = 186203, upload-time = "2026-01-10T09:23:05.01Z" },
+    { url = "https://files.pythonhosted.org/packages/37/e5/8e32857371406a757816a2b471939d51c463509be73fa538216ea52b792a/websockets-16.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:52ac480f44d32970d66763115edea932f1c5b1312de36df06d6b219f6741eed8", size = 185653, upload-time = "2026-01-10T09:23:06.301Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/67/f926bac29882894669368dc73f4da900fcdf47955d0a0185d60103df5737/websockets-16.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6e5a82b677f8f6f59e8dfc34ec06ca6b5b48bc4fcda346acd093694cc2c24d8f", size = 184920, upload-time = "2026-01-10T09:23:07.492Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/3d6ccdcd125b0a42a311bcd15a7f705d688f73b2a22d8cf1c0875d35d34a/websockets-16.0-cp313-cp313-win32.whl", hash = "sha256:abf050a199613f64c886ea10f38b47770a65154dc37181bfaff70c160f45315a", size = 178255, upload-time = "2026-01-10T09:23:09.245Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/ae/90366304d7c2ce80f9b826096a9e9048b4bb760e44d3b873bb272cba696b/websockets-16.0-cp313-cp313-win_amd64.whl", hash = "sha256:3425ac5cf448801335d6fdc7ae1eb22072055417a96cc6b31b3861f455fbc156", size = 178689, upload-time = "2026-01-10T09:23:10.483Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/1d/e88022630271f5bd349ed82417136281931e558d628dd52c4d8621b4a0b2/websockets-16.0-cp314-cp314-macosx_10_15_universal2.whl", hash = "sha256:8cc451a50f2aee53042ac52d2d053d08bf89bcb31ae799cb4487587661c038a0", size = 177406, upload-time = "2026-01-10T09:23:12.178Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/78/e63be1bf0724eeb4616efb1ae1c9044f7c3953b7957799abb5915bffd38e/websockets-16.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:daa3b6ff70a9241cf6c7fc9e949d41232d9d7d26fd3522b1ad2b4d62487e9904", size = 175085, upload-time = "2026-01-10T09:23:13.511Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/f4/d3c9220d818ee955ae390cf319a7c7a467beceb24f05ee7aaaa2414345ba/websockets-16.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:fd3cb4adb94a2a6e2b7c0d8d05cb94e6f1c81a0cf9dc2694fb65c7e8d94c42e4", size = 175328, upload-time = "2026-01-10T09:23:14.727Z" },
+    { url = "https://files.pythonhosted.org/packages/63/bc/d3e208028de777087e6fb2b122051a6ff7bbcca0d6df9d9c2bf1dd869ae9/websockets-16.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:781caf5e8eee67f663126490c2f96f40906594cb86b408a703630f95550a8c3e", size = 185044, upload-time = "2026-01-10T09:23:15.939Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/6e/9a0927ac24bd33a0a9af834d89e0abc7cfd8e13bed17a86407a66773cc0e/websockets-16.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:caab51a72c51973ca21fa8a18bd8165e1a0183f1ac7066a182ff27107b71e1a4", size = 186279, upload-time = "2026-01-10T09:23:17.148Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ca/bf1c68440d7a868180e11be653c85959502efd3a709323230314fda6e0b3/websockets-16.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:19c4dc84098e523fd63711e563077d39e90ec6702aff4b5d9e344a60cb3c0cb1", size = 185711, upload-time = "2026-01-10T09:23:18.372Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f8/fdc34643a989561f217bb477cbc47a3a07212cbda91c0e4389c43c296ebf/websockets-16.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:a5e18a238a2b2249c9a9235466b90e96ae4795672598a58772dd806edc7ac6d3", size = 184982, upload-time = "2026-01-10T09:23:19.652Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/d1/574fa27e233764dbac9c52730d63fcf2823b16f0856b3329fc6268d6ae4f/websockets-16.0-cp314-cp314-win32.whl", hash = "sha256:a069d734c4a043182729edd3e9f247c3b2a4035415a9172fd0f1b71658a320a8", size = 177915, upload-time = "2026-01-10T09:23:21.458Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/f1/ae6b937bf3126b5134ce1f482365fde31a357c784ac51852978768b5eff4/websockets-16.0-cp314-cp314-win_amd64.whl", hash = "sha256:c0ee0e63f23914732c6d7e0cce24915c48f3f1512ec1d079ed01fc629dab269d", size = 178381, upload-time = "2026-01-10T09:23:22.715Z" },
+    { url = "https://files.pythonhosted.org/packages/06/9b/f791d1db48403e1f0a27577a6beb37afae94254a8c6f08be4a23e4930bc0/websockets-16.0-cp314-cp314t-macosx_10_15_universal2.whl", hash = "sha256:a35539cacc3febb22b8f4d4a99cc79b104226a756aa7400adc722e83b0d03244", size = 177737, upload-time = "2026-01-10T09:23:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/40/53ad02341fa33b3ce489023f635367a4ac98b73570102ad2cdd770dacc9a/websockets-16.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:b784ca5de850f4ce93ec85d3269d24d4c82f22b7212023c974c401d4980ebc5e", size = 175268, upload-time = "2026-01-10T09:23:25.781Z" },
+    { url = "https://files.pythonhosted.org/packages/74/9b/6158d4e459b984f949dcbbb0c5d270154c7618e11c01029b9bbd1bb4c4f9/websockets-16.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:569d01a4e7fba956c5ae4fc988f0d4e187900f5497ce46339c996dbf24f17641", size = 175486, upload-time = "2026-01-10T09:23:27.033Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/2d/7583b30208b639c8090206f95073646c2c9ffd66f44df967981a64f849ad/websockets-16.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:50f23cdd8343b984957e4077839841146f67a3d31ab0d00e6b824e74c5b2f6e8", size = 185331, upload-time = "2026-01-10T09:23:28.259Z" },
+    { url = "https://files.pythonhosted.org/packages/45/b0/cce3784eb519b7b5ad680d14b9673a31ab8dcb7aad8b64d81709d2430aa8/websockets-16.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:152284a83a00c59b759697b7f9e9cddf4e3c7861dd0d964b472b70f78f89e80e", size = 186501, upload-time = "2026-01-10T09:23:29.449Z" },
+    { url = "https://files.pythonhosted.org/packages/19/60/b8ebe4c7e89fb5f6cdf080623c9d92789a53636950f7abacfc33fe2b3135/websockets-16.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:bc59589ab64b0022385f429b94697348a6a234e8ce22544e3681b2e9331b5944", size = 186062, upload-time = "2026-01-10T09:23:31.368Z" },
+    { url = "https://files.pythonhosted.org/packages/88/a8/a080593f89b0138b6cba1b28f8df5673b5506f72879322288b031337c0b8/websockets-16.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:32da954ffa2814258030e5a57bc73a3635463238e797c7375dc8091327434206", size = 185356, upload-time = "2026-01-10T09:23:32.627Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/b6/b9afed2afadddaf5ebb2afa801abf4b0868f42f8539bfe4b071b5266c9fe/websockets-16.0-cp314-cp314t-win32.whl", hash = "sha256:5a4b4cc550cb665dd8a47f868c8d04c8230f857363ad3c9caf7a0c3bf8c61ca6", size = 178085, upload-time = "2026-01-10T09:23:33.816Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3e/28135a24e384493fa804216b79a6a6759a38cc4ff59118787b9fb693df93/websockets-16.0-cp314-cp314t-win_amd64.whl", hash = "sha256:b14dc141ed6d2dde437cddb216004bcac6a1df0935d79656387bd41632ba0bbd", size = 178531, upload-time = "2026-01-10T09:23:35.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/28/258ebab549c2bf3e64d2b0217b973467394a9cea8c42f70418ca2c5d0d2e/websockets-16.0-py3-none-any.whl", hash = "sha256:1637db62fad1dc833276dded54215f2c7fa46912301a24bd94d45d46a011ceec", size = 171598, upload-time = "2026-01-10T09:23:45.395Z" },
 ]