gwmock.cli.utils.config_state¶

class ConfigState:
    """Mutable, section-aware wrapper around a gwmock config dict."""

    def __init__(self, data: dict[str, Any] | None = None) -> None:
        self._data: dict[str, Any] = data if data is not None else {}
        self.config_file: str | None = None

    # -- section access ----------------------------------------------------- #

    def set(self, section: str, key: str, raw_value: str) -> None:
        """Set *key* in *section* from a string *raw_value*."""
        keys_map = SECTION_KEYS.get(section)
        if keys_map is None:
            raise ValueError(f"Unknown section: {section}")
        path = keys_map.get(key)
        if path is None:
            valid = ", ".join(keys_map)
            raise ValueError(f"Unknown key '{key}' for /{section}. Valid keys: {valid}")
        types_map = SECTION_TYPES.get(section, {})
        target = types_map.get(key, str)
        value = _coerce(raw_value, target)
        _validate_value(key, value)
        _set(self._data, path, value)

    def get(self, section: str, key: str) -> Any:
        """Get *key* from *section*, or ``None`` if unset."""
        keys_map = SECTION_KEYS.get(section, {})
        path = keys_map.get(key)
        if path is None:
            return None
        return _get(self._data, path)

    def get_section(self, section: str) -> dict[str, Any] | None:
        """Return the raw dict for *section*, or ``None`` if empty."""
        mapping = {
            "noise": ["orchestration", "noise"],
            "signal": ["orchestration", "signal"],
            "population": ["orchestration", "population"],
            "globals": ["globals"],
            "batch": ["batch"],
        }
        path = mapping.get(section)
        if path is None:
            return None
        result = _get(self._data, path)
        if isinstance(result, dict) and result:
            return result
        return None

    def set_batch_resource(self, key: str, raw_value: str) -> None:
        _set(self._data, ["batch", "resources", key], raw_value)

    def set_batch_submit(self, key: str, raw_value: str) -> None:
        _set(self._data, ["batch", "submit", key], raw_value)

    # -- glitch helpers ---------------------------------------------------- #

    def add_glitch(self, kind: str) -> int:
        glitches = _get(self._data, ["orchestration", "noise", "arguments", "glitches"], [])
        if not isinstance(glitches, list):
            glitches = []
        glitches.append({"kind": kind})
        _set(self._data, ["orchestration", "noise", "arguments", "glitches"], glitches)
        return len(glitches) - 1

    def remove_glitch(self, index: int) -> dict[str, Any]:
        glitches = _get(self._data, ["orchestration", "noise", "arguments", "glitches"], [])
        if not isinstance(glitches, list) or not (0 <= index < len(glitches)):
            raise IndexError(f"Glitch index {index} out of range (have {len(glitches)} glitches)")
        removed = glitches.pop(index)
        if glitches:
            _set(self._data, ["orchestration", "noise", "arguments", "glitches"], glitches)
        else:
            _delete(self._data, ["orchestration", "noise", "arguments", "glitches"])
        return removed

    # -- reset ------------------------------------------------------------- #

    def reset(self, section: str | None = None) -> None:
        if section is None:
            self._data = {}
            return
        mapping = {
            "noise": ["orchestration", "noise"],
            "signal": ["orchestration", "signal"],
            "population": ["orchestration", "population"],
            "globals": ["globals"],
            "batch": ["batch"],
        }
        path = mapping.get(section)
        if path is None:
            raise ValueError(f"Unknown section: {section}")
        _delete(self._data, path)

    # -- serialisation ----------------------------------------------------- #

    def to_dict(self) -> dict[str, Any]:
        return _clean_empty(self._data)

    def load(self, path: Path) -> None:
        with open(path, encoding="utf-8") as f:
            data = yaml.safe_load(f)
        if not isinstance(data, dict):
            raise ValueError("Configuration file must contain a YAML mapping")
        self._data = _clean_none(data)

    def validate(self) -> tuple[bool, str]:
        from gwmock.cli.utils.config import Config  # noqa: PLC0415

        try:
            Config(**self.to_dict())
            return True, ""
        except Exception as e:
            return False, str(e)

    @property
    def is_empty(self) -> bool:
        return not self._data or not _clean_empty(self._data)