voson
1d0428b4a3
- New web/relations/router.js (parseHash/serializeHash/installRouter): top tabs, hero + detail sub-tab, item, patch version, tag filters and search query all sync to URL (#/heroes/axe/core, ?tags=...&q=...); pushState for discrete picks, replaceState for debounced search. - export_relations_site.py copies router.js so static export deep-links. - Header shows dota2_logo.png + title, served via /ui-icon/ whitelist. - fetch_dota2_logo.py fetches the transparent emblem asset. - Docs: CHANGELOG / README / DESIGN / AGENTS updated.
583 lines
22 KiB
Python
583 lines
22 KiB
Python
"""Local read-only preview for qualitative hero relations.
|
|
|
|
Usage:
|
|
python serve_relations.py
|
|
python serve_relations.py --port 8765
|
|
|
|
Select a hero to see 克制 / 被克制 / 搭档 highlights and feared items.
|
|
Edit data/relations.json directly, then refresh the page.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import mimetypes
|
|
import webbrowser
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from urllib.parse import urlparse
|
|
|
|
import urllib.error
|
|
|
|
from common import (
|
|
ABILITY_ICONS,
|
|
ABILITY_VIDEOS,
|
|
ATTR_ICONS,
|
|
HERO_PORTRAITS,
|
|
ITEM_CAT_ICONS,
|
|
ITEM_ICONS,
|
|
ROOT,
|
|
TEMPLATES_CDN,
|
|
UI_ICONS,
|
|
)
|
|
from grid import ATTR_ORDER, hero_table
|
|
from hero_tags import TAG_ORDER, tags_for_hero
|
|
from http_utils import http_bytes
|
|
from relations import DEFAULT_RELATIONS, load_relations
|
|
|
|
WEB_DIR = ROOT / "web" / "relations"
|
|
GRID_ORDER_PATH = ROOT / "data" / "hero_grid_order.json"
|
|
HERO_ITEMS_PATH = ROOT / "data" / "hero_items.json"
|
|
HERO_ITEM_FEARS_PATH = ROOT / "data" / "hero_item_fears.json"
|
|
HERO_ABILITIES_PATH = ROOT / "data" / "hero_abilities.json"
|
|
ITEM_SHOP_PATH = ROOT / "data" / "item_shop.json"
|
|
ITEMS_META_PATH = ROOT / "data" / "items_meta.json"
|
|
PATCHES_PATH = ROOT / "data" / "patches.json"
|
|
ATTR_COLS = {"str": 6, "agi": 6, "int": 6, "all": 4}
|
|
ATTR_LABELS = {"str": "力量", "agi": "敏捷", "int": "智力", "all": "全才"}
|
|
ABILITY_ICON_URL = (
|
|
"https://cdn.cloudflare.steamstatic.com/apps/dota2/images/dota_react/abilities/{key}.png"
|
|
)
|
|
# Shared innate badge (official-style gold droplet); UI falls back here when CDN 404s.
|
|
INNATE_ICON_NAME = "innate"
|
|
# Bundled talent-tree trigger icon (not fetched from CDN).
|
|
TALENT_TREE_ICON_NAME = "talent_tree"
|
|
|
|
|
|
def load_hero_items() -> dict:
|
|
"""Cached OpenDota item popularity (see fetch_hero_items.py)."""
|
|
empty = {"meta": {}, "items": {}, "by_hero": {}}
|
|
if not HERO_ITEMS_PATH.is_file():
|
|
return empty
|
|
try:
|
|
raw = json.loads(HERO_ITEMS_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return empty
|
|
return {
|
|
"meta": dict(raw.get("meta") or {}),
|
|
"items": dict(raw.get("items") or {}),
|
|
"by_hero": dict(raw.get("by_hero") or {}),
|
|
}
|
|
|
|
|
|
def load_hero_item_fears() -> dict:
|
|
"""Cached rule-based items that counter each hero (see item_fears.py)."""
|
|
empty = {"meta": {}, "items": {}, "by_hero": {}}
|
|
if not HERO_ITEM_FEARS_PATH.is_file():
|
|
return empty
|
|
try:
|
|
raw = json.loads(HERO_ITEM_FEARS_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return empty
|
|
return {
|
|
"meta": dict(raw.get("meta") or {}),
|
|
"items": dict(raw.get("items") or {}),
|
|
"by_hero": dict(raw.get("by_hero") or {}),
|
|
}
|
|
|
|
|
|
def load_items_meta_index() -> dict:
|
|
"""key → slim item row (desc/tags/cost) for hero-page inspect lookups."""
|
|
out: dict[str, dict] = {}
|
|
if not ITEMS_META_PATH.is_file():
|
|
return out
|
|
try:
|
|
raw = json.loads(ITEMS_META_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return out
|
|
for row in (raw.get("items") or {}).values():
|
|
if not isinstance(row, dict) or not row.get("key"):
|
|
continue
|
|
key = str(row["key"])
|
|
out[key] = {
|
|
"key": key,
|
|
"name_loc": row.get("name_loc") or row.get("dname") or key,
|
|
"cost": row.get("cost"),
|
|
"desc_loc": row.get("desc_loc") or "",
|
|
"tags": list(row.get("tags") or []),
|
|
}
|
|
return out
|
|
|
|
|
|
def load_item_shop() -> dict:
|
|
"""Full shop catalog for the Items page (see fetch_item_shop.py)."""
|
|
empty = {
|
|
"meta": {},
|
|
"basic": {"sections": []},
|
|
"upgraded": {"sections": []},
|
|
"items": {},
|
|
}
|
|
if not ITEM_SHOP_PATH.is_file():
|
|
return empty
|
|
try:
|
|
raw = json.loads(ITEM_SHOP_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return empty
|
|
items = dict(raw.get("items") or {})
|
|
# Merge mechanism tags / short desc from items_meta when present.
|
|
if ITEMS_META_PATH.is_file():
|
|
try:
|
|
meta = json.loads(ITEMS_META_PATH.read_text(encoding="utf-8"))
|
|
by_key = {}
|
|
for row in (meta.get("items") or {}).values():
|
|
if isinstance(row, dict) and row.get("key"):
|
|
by_key[row["key"]] = row
|
|
for key, row in items.items():
|
|
m = by_key.get(key)
|
|
if not m:
|
|
continue
|
|
row = dict(row)
|
|
row["tags"] = list(m.get("tags") or [])
|
|
row["desc_loc"] = m.get("desc_loc") or ""
|
|
items[key] = row
|
|
except (OSError, json.JSONDecodeError):
|
|
pass
|
|
return {
|
|
"meta": dict(raw.get("meta") or {}),
|
|
"basic": dict(raw.get("basic") or {"sections": []}),
|
|
"upgraded": dict(raw.get("upgraded") or {"sections": []}),
|
|
"items": items,
|
|
}
|
|
|
|
|
|
def load_patches() -> dict:
|
|
"""Patch list + per-patch details + id lookup (see fetch_patches.py).
|
|
|
|
Returns {patches, lookup, details}; empty-shaped when the file is missing
|
|
so the preview UI degrades to "no data" instead of crashing.
|
|
"""
|
|
empty = {"patches": [], "lookup": {}, "details": {}}
|
|
if not PATCHES_PATH.is_file():
|
|
return empty
|
|
try:
|
|
raw = json.loads(PATCHES_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return empty
|
|
return {
|
|
"patches": list(raw.get("patches") or []),
|
|
"lookup": dict(raw.get("lookup") or {}),
|
|
"details": dict(raw.get("details") or {}),
|
|
}
|
|
|
|
|
|
def load_hero_abilities() -> dict:
|
|
"""Slim per-hero abilities / Aghs upgrades / talents for the preview pane."""
|
|
empty = {"meta": {}, "by_hero": {}}
|
|
if not HERO_ABILITIES_PATH.is_file():
|
|
return empty
|
|
try:
|
|
raw = json.loads(HERO_ABILITIES_PATH.read_text(encoding="utf-8"))
|
|
except (OSError, json.JSONDecodeError):
|
|
return empty
|
|
by_hero: dict[str, dict] = {}
|
|
for key, cell in (raw.get("by_hero") or {}).items():
|
|
if not isinstance(cell, dict):
|
|
continue
|
|
abs_out = []
|
|
for ab in cell.get("abilities") or []:
|
|
if not isinstance(ab, dict) or not ab.get("key"):
|
|
continue
|
|
specials = [
|
|
{"label": str(s["label"]), "value": str(s["value"])}
|
|
for s in (ab.get("specials") or [])
|
|
if isinstance(s, dict) and s.get("label") and s.get("value")
|
|
]
|
|
abs_out.append(
|
|
{
|
|
"key": ab["key"],
|
|
"name_loc": ab.get("name_loc") or ab["key"],
|
|
"desc_loc": ab.get("desc_loc") or "",
|
|
"shard_loc": ab.get("shard_loc") or "",
|
|
"scepter_loc": ab.get("scepter_loc") or "",
|
|
"has_shard": bool(ab.get("has_shard")),
|
|
"has_scepter": bool(ab.get("has_scepter")),
|
|
"granted_by_shard": bool(ab.get("granted_by_shard")),
|
|
"granted_by_scepter": bool(ab.get("granted_by_scepter")),
|
|
"dispellable": ab.get("dispellable") or "none",
|
|
"is_innate": bool(ab.get("is_innate")),
|
|
"target_label": ab.get("target_label") or "",
|
|
"affects_label": ab.get("affects_label") or "",
|
|
"damage_label": ab.get("damage_label") or "",
|
|
"immunity_label": ab.get("immunity_label") or "",
|
|
"cast_range": ab.get("cast_range") or "",
|
|
"cast_point": ab.get("cast_point") or "",
|
|
"channel_time": ab.get("channel_time") or "",
|
|
"cooldown": ab.get("cooldown") or "",
|
|
"mana_cost": ab.get("mana_cost") or "",
|
|
"specials": specials,
|
|
"lore_loc": ab.get("lore_loc") or "",
|
|
}
|
|
)
|
|
talents_out = []
|
|
for tal in cell.get("talents") or []:
|
|
if not isinstance(tal, dict) or not tal.get("key"):
|
|
continue
|
|
talents_out.append(
|
|
{
|
|
"key": tal["key"],
|
|
"name_loc": tal.get("name_loc") or tal["key"],
|
|
"level": int(tal.get("level") or 0),
|
|
"side": tal.get("side") or "left",
|
|
}
|
|
)
|
|
by_hero[str(key)] = {
|
|
"abilities": abs_out,
|
|
"talents": talents_out,
|
|
}
|
|
return {
|
|
"meta": dict(raw.get("meta") or {}),
|
|
"by_hero": by_hero,
|
|
}
|
|
|
|
|
|
def ensure_ability_icon(key: str) -> Path | None:
|
|
"""Return local ability icon path, downloading from Steam CDN on miss.
|
|
|
|
``innate.png`` / ``talent_tree.png`` are bundled shared badges (not fetched
|
|
from CDN). Many innate ability keys 404 on Steam ``dota_react/abilities``;
|
|
the preview UI falls back to ``innate.png`` when a per-ability icon is missing.
|
|
"""
|
|
if not key or "/" in key or "\\" in key or ".." in key:
|
|
return None
|
|
ABILITY_ICONS.mkdir(parents=True, exist_ok=True)
|
|
dest = ABILITY_ICONS / f"{key}.png"
|
|
if dest.is_file() and dest.stat().st_size >= 32:
|
|
return dest
|
|
if key in (INNATE_ICON_NAME, TALENT_TREE_ICON_NAME):
|
|
return None
|
|
try:
|
|
data = http_bytes(ABILITY_ICON_URL.format(key=key), timeout=30)
|
|
if not data or len(data) < 32:
|
|
return None
|
|
dest.write_bytes(data)
|
|
return dest
|
|
except (urllib.error.URLError, TimeoutError, OSError):
|
|
return None
|
|
|
|
|
|
def load_grid_order() -> dict[str, list[str]]:
|
|
"""Column membership + order for the pick grid (see data/hero_grid_order.json)."""
|
|
if not GRID_ORDER_PATH.is_file():
|
|
return {}
|
|
raw = json.loads(GRID_ORDER_PATH.read_text(encoding="utf-8"))
|
|
out: dict[str, list[str]] = {}
|
|
for attr in ATTR_ORDER:
|
|
keys = raw.get(attr) or []
|
|
if isinstance(keys, list):
|
|
out[attr] = [str(k) for k in keys if isinstance(k, str) and not k.startswith("_")]
|
|
return out
|
|
|
|
|
|
def build_payload() -> dict:
|
|
heroes = hero_table()
|
|
by_key = {}
|
|
slim = []
|
|
for h in heroes:
|
|
roles = list(h.get("roles") or [])
|
|
tags = list(h.get("tags") or []) or tags_for_hero(h["key"], roles)
|
|
row = {
|
|
"id": int(h["id"]),
|
|
"key": h["key"],
|
|
"name": h.get("name") or h["key"],
|
|
"name_loc": h.get("name_loc") or h["key"],
|
|
"aliases": list(h.get("aliases") or []),
|
|
"abbr": [str(a).lower() for a in (h.get("abbr") or []) if str(a).strip()],
|
|
"attr": h.get("attr") or "all",
|
|
"roles": roles,
|
|
"tags": tags,
|
|
}
|
|
# Level-1 strip + combat stats (from OpenDota via fetch_cdn_templates.py).
|
|
for key in (
|
|
"base_str",
|
|
"str_gain",
|
|
"base_agi",
|
|
"agi_gain",
|
|
"base_int",
|
|
"int_gain",
|
|
"health",
|
|
"mana",
|
|
"health_regen",
|
|
"mana_regen",
|
|
"armor",
|
|
"damage_min",
|
|
"damage_max",
|
|
"move_speed",
|
|
"attack_range",
|
|
"attack_rate",
|
|
"projectile_speed",
|
|
"magic_resist",
|
|
"turn_rate",
|
|
"vision_day",
|
|
"vision_night",
|
|
):
|
|
if key in h and h[key] is not None:
|
|
row[key] = h[key]
|
|
slim.append(row)
|
|
by_key[row["key"]] = row
|
|
|
|
grid = load_grid_order()
|
|
by_attr: dict[str, list[dict]] = {a: [] for a in ATTR_ORDER}
|
|
placed: set[str] = set()
|
|
for attr in ATTR_ORDER:
|
|
for key in grid.get(attr) or []:
|
|
row = by_key.get(key)
|
|
if row is None or key in placed:
|
|
continue
|
|
by_attr[attr].append(row)
|
|
placed.add(key)
|
|
# Heroes missing from the order file → append under their primary attr.
|
|
rest = [r for r in slim if r["key"] not in placed]
|
|
rest.sort(key=lambda r: r["id"])
|
|
for row in rest:
|
|
attr = row["attr"] if row["attr"] in by_attr else "all"
|
|
by_attr[attr].append(row)
|
|
|
|
slim_ordered: list[dict] = []
|
|
for attr in ATTR_ORDER:
|
|
slim_ordered.extend(by_attr[attr])
|
|
|
|
rel = load_relations()
|
|
items = load_hero_items()
|
|
fears = load_hero_item_fears()
|
|
abilities = load_hero_abilities()
|
|
shop = load_item_shop()
|
|
items_meta = load_items_meta_index()
|
|
patches_data = load_patches()
|
|
# Attach craft graph from shop catalog when available.
|
|
for key, row in (shop.get("items") or {}).items():
|
|
if not isinstance(row, dict):
|
|
continue
|
|
cell = items_meta.setdefault(key, {"key": key})
|
|
cell.setdefault("name_loc", row.get("name_loc") or key)
|
|
if row.get("cost") is not None:
|
|
cell["cost"] = row.get("cost")
|
|
if row.get("desc_loc"):
|
|
cell["desc_loc"] = row.get("desc_loc")
|
|
cell["components"] = list(row.get("components") or [])
|
|
cell["builds_into"] = list(row.get("builds_into") or [])
|
|
return {
|
|
"heroes": slim_ordered,
|
|
"by_attr": by_attr,
|
|
"attr_order": list(ATTR_ORDER),
|
|
"attr_cols": ATTR_COLS,
|
|
"attr_labels": ATTR_LABELS,
|
|
"tag_order": list(TAG_ORDER),
|
|
"relations": rel,
|
|
"hero_items": items,
|
|
"hero_item_fears": fears,
|
|
"hero_abilities": abilities,
|
|
"item_shop": shop,
|
|
"items_meta": items_meta,
|
|
"patches": patches_data.get("patches") or [],
|
|
"patch_lookup": patches_data.get("lookup") or {},
|
|
"patch_details": patches_data.get("details") or {},
|
|
"meta": {
|
|
"relations_path": str(DEFAULT_RELATIONS.relative_to(ROOT)).replace("\\", "/"),
|
|
"grid_order_path": str(GRID_ORDER_PATH.relative_to(ROOT)).replace("\\", "/"),
|
|
"hero_items_path": str(HERO_ITEMS_PATH.relative_to(ROOT)).replace("\\", "/"),
|
|
"hero_item_fears_path": str(HERO_ITEM_FEARS_PATH.relative_to(ROOT)).replace(
|
|
"\\", "/"
|
|
),
|
|
"hero_abilities_path": str(HERO_ABILITIES_PATH.relative_to(ROOT)).replace(
|
|
"\\", "/"
|
|
),
|
|
"item_shop_path": str(ITEM_SHOP_PATH.relative_to(ROOT)).replace("\\", "/"),
|
|
"source": (rel.get("meta") or {}).get("source"),
|
|
"counters": len(rel.get("counters") or []),
|
|
"synergies": len(rel.get("synergies") or []),
|
|
"item_heroes": len(items.get("by_hero") or {}),
|
|
"fear_heroes": len(fears.get("by_hero") or {}),
|
|
"ability_heroes": len(abilities.get("by_hero") or {}),
|
|
"shop_items": len(shop.get("items") or {}),
|
|
"patches": len(patches_data.get("patches") or []),
|
|
"patch_details": len(patches_data.get("details") or {}),
|
|
},
|
|
}
|
|
|
|
|
|
class Handler(BaseHTTPRequestHandler):
|
|
server_version = "ClimperorRelations/2.0"
|
|
|
|
def log_message(self, fmt: str, *args) -> None:
|
|
print(f"[relations] {self.address_string()} {fmt % args}")
|
|
|
|
def _send(self, code: int, body: bytes, content_type: str) -> None:
|
|
self.send_response(code)
|
|
self.send_header("Content-Type", content_type)
|
|
self.send_header("Content-Length", str(len(body)))
|
|
self.send_header("Cache-Control", "no-store")
|
|
self.end_headers()
|
|
self.wfile.write(body)
|
|
|
|
def _json(self, code: int, obj: object) -> None:
|
|
self._send(code, json.dumps(obj, ensure_ascii=False).encode("utf-8"),
|
|
"application/json; charset=utf-8")
|
|
|
|
def do_GET(self) -> None: # noqa: N802
|
|
path = urlparse(self.path).path
|
|
if path in ("/", "/index.html"):
|
|
index = WEB_DIR / "index.html"
|
|
if not index.is_file():
|
|
self._json(500, {"error": "web/relations/index.html missing"})
|
|
return
|
|
self._send(200, index.read_bytes(), "text/html; charset=utf-8")
|
|
return
|
|
if path in ("/api/data", "/data.json"):
|
|
self._json(200, build_payload())
|
|
return
|
|
if path.startswith("/attr/"):
|
|
key = path[len("/attr/") :]
|
|
if key not in ("str.png", "agi.png", "int.png", "all.png"):
|
|
self._json(400, {"error": "bad attr icon"})
|
|
return
|
|
fpath = ATTR_ICONS / key
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/ui-icon/"):
|
|
key = path[len("/ui-icon/") :]
|
|
if key not in ("cooldown.png", "dota2_logo.png"):
|
|
self._json(400, {"error": "bad ui icon"})
|
|
return
|
|
fpath = UI_ICONS / key
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/portrait/") or path.startswith("/cdn/"):
|
|
prefix = "/portrait/" if path.startswith("/portrait/") else "/cdn/"
|
|
key = path[len(prefix) :]
|
|
if "/" in key or "\\" in key or not key.endswith(".png"):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
# Prefer official Heroes-page cards; fall back to match templates.
|
|
fpath = HERO_PORTRAITS / key
|
|
if not fpath.is_file():
|
|
fpath = TEMPLATES_CDN / key
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/item-cat/"):
|
|
key = path[len("/item-cat/") :]
|
|
if "/" in key or "\\" in key or not key.endswith(".png"):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
if not key.startswith("itemcat_"):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
fpath = ITEM_CAT_ICONS / key
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/item/"):
|
|
key = path[len("/item/") :]
|
|
if "/" in key or "\\" in key or not key.endswith(".png"):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
fpath = ITEM_ICONS / key
|
|
# All recipe scrolls share recipe.png on Steam CDN.
|
|
if not fpath.is_file() and key.startswith("recipe_"):
|
|
fpath = ITEM_ICONS / "recipe.png"
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/ability/"):
|
|
key = path[len("/ability/") :]
|
|
if "/" in key or "\\" in key or not key.endswith(".png"):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
stem = key[: -len(".png")]
|
|
fpath = ensure_ability_icon(stem)
|
|
if fpath is None:
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), "image/png")
|
|
return
|
|
if path.startswith("/ability-video/"):
|
|
rel_path = path[len("/ability-video/") :]
|
|
parts = rel_path.split("/")
|
|
if len(parts) != 2:
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
hero, fname = parts
|
|
if (
|
|
not hero
|
|
or ".." in hero
|
|
or "\\" in hero
|
|
or ".." in fname
|
|
or "\\" in fname
|
|
):
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
if fname.endswith(".webm"):
|
|
ctype = "video/webm"
|
|
elif fname.endswith(".mp4"):
|
|
ctype = "video/mp4"
|
|
else:
|
|
self._json(400, {"error": "bad path"})
|
|
return
|
|
fpath = ABILITY_VIDEOS / hero / fname
|
|
if not fpath.is_file():
|
|
self.send_error(404)
|
|
return
|
|
self._send(200, fpath.read_bytes(), ctype)
|
|
return
|
|
rel = path.lstrip("/")
|
|
candidate = (WEB_DIR / rel).resolve()
|
|
if not str(candidate).startswith(str(WEB_DIR.resolve())) or not candidate.is_file():
|
|
self.send_error(404)
|
|
return
|
|
ctype = mimetypes.guess_type(str(candidate))[0] or "application/octet-stream"
|
|
self._send(200, candidate.read_bytes(), ctype)
|
|
|
|
|
|
def main() -> None:
|
|
ap = argparse.ArgumentParser(description="Preview qualitative hero relations (read-only)")
|
|
ap.add_argument("--port", type=int, default=8765)
|
|
ap.add_argument("--host", default="127.0.0.1")
|
|
ap.add_argument("--no-browser", action="store_true")
|
|
args = ap.parse_args()
|
|
|
|
if not (WEB_DIR / "index.html").is_file():
|
|
raise SystemExit(f"missing UI: {WEB_DIR / 'index.html'}")
|
|
if not TEMPLATES_CDN.is_dir():
|
|
raise SystemExit("templates/cdn missing — run python fetch_cdn_templates.py")
|
|
|
|
httpd = ThreadingHTTPServer((args.host, args.port), Handler)
|
|
url = f"http://{args.host}:{args.port}/"
|
|
print(f"relations preview: {url}")
|
|
print(f"edit JSON then refresh: {DEFAULT_RELATIONS}")
|
|
if not args.no_browser:
|
|
try:
|
|
webbrowser.open(url)
|
|
except Exception: # noqa: BLE001
|
|
pass
|
|
try:
|
|
httpd.serve_forever()
|
|
except KeyboardInterrupt:
|
|
print("\nstopped")
|
|
httpd.server_close()
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|