Class RoutingConfigStore

uncommon_route/routing_config_store.py:134–250

class RoutingConfigStore:
    def __init__(
        self,
        storage: RoutingConfigStorage | None = None,
        base_config: RoutingConfig | None = None,
    ) -> None:
        self._storage = storage or FileRoutingConfigStorage()
        self._base_config = copy.deepcopy(base_config or DEFAULT_CONFIG)
        raw = self._storage.load()
        self._overrides = _sanitize_overrides(raw)
        self._default_mode = _sanitize_default_mode(raw)

    def config(self) -> RoutingConfig:
        cfg: RoutingConfig = copy.deepcopy(self._base_config)
        for mode_name, tier_map in self._overrides.items():
            mode = RoutingMode(mode_name)
            table = _mode_table(cfg, mode)
            for tier_name, payload in tier_map.items():
                tier = Tier(tier_name)
                table[tier] = TierConfig(
                    primary=str(payload["primary"]),
                    fallback=list(payload.get("fallback", [])),
                    hard_pin=bool(payload.get("hard_pin", False)),
                )
        return cfg

    def export(self) -> dict[str, Any]:
        cfg = self.config()
        modes: dict[str, dict[str, Any]] = {}
        for mode in RoutingMode:
            active = _mode_table(cfg, mode)
            overridden_tiers = self._overrides.get(mode.value, {})
            tier_rows: dict[str, Any] = {}
            for tier in Tier:
                tc = active[tier]
                tier_rows[tier.value] = {
                    "primary": tc.primary,
                    "fallback": list(tc.fallback),
                    "overridden": tier.value in overridden_tiers,
                    "hard_pin": tc.hard_pin,
                    "selection_mode": "hard-pin" if tc.hard_pin else "adaptive",
                }
            modes[mode.value] = {"tiers": tier_rows}
        return {
            "source": "local-file",
            "editable": True,
            "default_mode": self._default_mode.value,
            "modes": modes,
        }

    def default_mode(self) -> RoutingMode:
        return self._default_mode

    def set_default_mode(self, mode: RoutingMode) -> dict[str, Any]:
        self._default_mode = mode
        self._persist()
        return self.export()