185 lines
5.1 KiB
Python
185 lines
5.1 KiB
Python
"""
|
|
Site-level rule loading shared by routing, startup pages, and defaults.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import copy
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
from typing import Any, Dict, List, Tuple
|
|
|
|
|
|
_PROJECT_ROOT = Path(__file__).resolve().parents[2]
|
|
_SITE_RULES_FILE = Path(
|
|
os.getenv("SITE_RULES_FILE", str(_PROJECT_ROOT / "config" / "site_rules.json"))
|
|
)
|
|
_SITES_LOCAL_FILE = Path(
|
|
os.getenv("SITES_LOCAL_FILE", str(_PROJECT_ROOT / "config" / "sites.local.json"))
|
|
)
|
|
|
|
_IGNORED_SITE_ID_PARTS = {
|
|
"",
|
|
"www",
|
|
"chat",
|
|
"web",
|
|
"app",
|
|
"api",
|
|
"beta",
|
|
"console",
|
|
"new",
|
|
}
|
|
|
|
_SITE_RULES_CACHE: Dict[str, Any] = {
|
|
"signature": None,
|
|
"rules": {},
|
|
}
|
|
|
|
|
|
def _normalize_domain(value: Any) -> str:
|
|
return str(value or "").strip().lower().strip(".")
|
|
|
|
|
|
def _normalize_rule(rule: Any) -> Dict[str, Any]:
|
|
if not isinstance(rule, dict):
|
|
return {}
|
|
|
|
normalized: Dict[str, Any] = {}
|
|
|
|
display_name = str(rule.get("display_name") or "").strip()
|
|
if display_name:
|
|
normalized["display_name"] = display_name
|
|
|
|
startup_url = str(rule.get("startup_url") or "").strip()
|
|
if startup_url:
|
|
normalized["startup_url"] = startup_url
|
|
|
|
card_id = str(rule.get("card_id") or "").strip()
|
|
if card_id:
|
|
normalized["card_id"] = card_id
|
|
|
|
guide_priority = rule.get("guide_priority", None)
|
|
if isinstance(guide_priority, (int, float)) and not isinstance(guide_priority, bool):
|
|
normalized["guide_priority"] = int(guide_priority)
|
|
|
|
if isinstance(rule.get("auto_discovery"), bool):
|
|
normalized["auto_discovery"] = rule["auto_discovery"]
|
|
|
|
if "stealth_default" in rule:
|
|
normalized["stealth_default"] = bool(rule.get("stealth_default"))
|
|
|
|
route_aliases = rule.get("route_aliases", [])
|
|
if isinstance(route_aliases, list):
|
|
aliases: List[str] = []
|
|
seen = set()
|
|
for raw_alias in route_aliases:
|
|
alias = _normalize_domain(raw_alias)
|
|
if not alias or alias in seen:
|
|
continue
|
|
seen.add(alias)
|
|
aliases.append(alias)
|
|
normalized["route_aliases"] = aliases
|
|
|
|
return normalized
|
|
|
|
|
|
def _read_json_file(path: Path) -> Dict[str, Any]:
|
|
if not path.exists():
|
|
return {}
|
|
|
|
try:
|
|
with open(path, "r", encoding="utf-8-sig") as handle:
|
|
data = json.load(handle)
|
|
return data if isinstance(data, dict) else {}
|
|
except Exception:
|
|
return {}
|
|
|
|
|
|
def _build_cache_signature() -> Tuple[Tuple[str, float], ...]:
|
|
signature: List[Tuple[str, float]] = []
|
|
for path in (_SITE_RULES_FILE, _SITES_LOCAL_FILE):
|
|
try:
|
|
mtime = path.stat().st_mtime if path.exists() else 0.0
|
|
except Exception:
|
|
mtime = 0.0
|
|
signature.append((str(path), float(mtime)))
|
|
return tuple(signature)
|
|
|
|
|
|
def _load_rules_from_files() -> Dict[str, Dict[str, Any]]:
|
|
shipped = _read_json_file(_SITE_RULES_FILE).get("sites", {})
|
|
local = _read_json_file(_SITES_LOCAL_FILE).get("site_overrides", {})
|
|
|
|
merged: Dict[str, Dict[str, Any]] = {}
|
|
for source in (shipped, local):
|
|
if not isinstance(source, dict):
|
|
continue
|
|
for raw_domain, raw_rule in source.items():
|
|
domain = _normalize_domain(raw_domain)
|
|
if not domain:
|
|
continue
|
|
current = merged.setdefault(domain, {})
|
|
current.update(_normalize_rule(raw_rule))
|
|
|
|
return merged
|
|
|
|
|
|
def load_site_rules(force: bool = False) -> Dict[str, Dict[str, Any]]:
|
|
signature = _build_cache_signature()
|
|
if not force and _SITE_RULES_CACHE.get("signature") == signature:
|
|
return copy.deepcopy(_SITE_RULES_CACHE.get("rules", {}))
|
|
|
|
rules = _load_rules_from_files()
|
|
_SITE_RULES_CACHE["signature"] = signature
|
|
_SITE_RULES_CACHE["rules"] = rules
|
|
return copy.deepcopy(rules)
|
|
|
|
|
|
def get_site_rule(domain: str) -> Dict[str, Any]:
|
|
normalized = _normalize_domain(domain)
|
|
if not normalized:
|
|
return {}
|
|
return load_site_rules().get(normalized, {})
|
|
|
|
|
|
def build_route_alias_groups() -> Tuple[Tuple[str, ...], ...]:
|
|
groups: List[Tuple[str, ...]] = []
|
|
for domain, rule in load_site_rules().items():
|
|
ordered: List[str] = []
|
|
seen = set()
|
|
for item in list(rule.get("route_aliases", []) or []) + [domain]:
|
|
alias = _normalize_domain(item)
|
|
if not alias or alias in seen:
|
|
continue
|
|
seen.add(alias)
|
|
ordered.append(alias)
|
|
if len(ordered) >= 2:
|
|
groups.append(tuple(ordered))
|
|
return tuple(groups)
|
|
|
|
|
|
def derive_site_card_id(domain: str) -> str:
|
|
normalized = _normalize_domain(domain)
|
|
if not normalized:
|
|
return ""
|
|
|
|
rule = get_site_rule(normalized)
|
|
explicit = str(rule.get("card_id") or "").strip()
|
|
if explicit:
|
|
return explicit
|
|
|
|
parts = [part for part in normalized.split(".")[:-1] if part not in _IGNORED_SITE_ID_PARTS]
|
|
if parts:
|
|
return parts[0]
|
|
|
|
return normalized.split(".", 1)[0]
|
|
|
|
|
|
__all__ = [
|
|
"build_route_alias_groups",
|
|
"derive_site_card_id",
|
|
"get_site_rule",
|
|
"load_site_rules",
|
|
]
|