reqm 0.1.0__py3-none-any.whl

reqm/__init__.py

@@ -0,0 +1,6 @@
+# reqm — Ridiculously Easy Quant Manager
+
+from reqm.quant import Quant
+from reqm.quant_manager import ConfigValidationError, QuantManager
+
+__all__ = ["ConfigValidationError", "Quant", "QuantManager"]

reqm/overrides_ext.py

@@ -0,0 +1,165 @@
+"""
+overrides_ext.py — Extended override utilities for reqm.
+
+A thin extension of the `overrides` library that adds `allow_any_override`,
+a marker for abstract methods whose signature subclasses are permitted to narrow.
+
+The problem this solves:
+    Quant defines ``__call__(self, **kwargs)`` as abstract so subclasses can
+    narrow it to any specific signature (e.g. ``__call__(self, text: str)``).
+    The vanilla ``@override`` would reject this as a signature mismatch.
+    ``@allow_any_override`` on the base method tells our ``@override`` to skip
+    signature checking for that particular method — while keeping it enforced
+    for all other overrides.
+
+Public API:
+    allow_any_override  — marker decorator for base methods
+    override            — drop-in for @override, respects @allow_any_override
+    final               — re-export from overrides library (unchanged)
+    EnforceOverrides    — re-export from overrides library (unchanged)
+
+Usage::
+
+    from reqm.overrides_ext import allow_any_override, override, EnforceOverrides
+
+    class Base(EnforceOverrides):
+        @abstractmethod
+        @allow_any_override
+        def __call__(self, **kwargs) -> Any: ...       # any signature OK
+
+        @abstractmethod
+        def name(self) -> str: ...                     # signature enforced
+
+    class Child(Base):
+        @override
+        def __call__(self, text: str) -> str: ...      # different sig — allowed
+
+        @override
+        def name(self) -> str: ...                     # same sig — required
+"""
+
+import sys
+import typing as ty
+
+from overrides import EnforceOverrides, final
+from overrides.overrides import _get_base_classes, _overrides
+
+F = ty.TypeVar("F", bound=ty.Callable[..., ty.Any])
+
+
+def _should_enforce_signature(method: ty.Callable) -> bool:
+    """Decide whether signature checking applies for this override.
+
+    Returns False if the method itself carries ``@allow_any_override``, or if
+    every parent definition of the same method carries it.  Returns True as
+    soon as any parent definition is found *without* the marker.
+
+    Raises:
+        TypeError: If no parent class defines a method with the same name.
+    """
+    if getattr(method, "__allow_any_override__", False):
+        return False
+
+    global_vars = getattr(method, "__globals__", None)
+    if global_vars is None:
+        global_vars = vars(sys.modules[method.__module__])
+
+    found = False
+    for super_class in _get_base_classes(sys._getframe(3), global_vars):
+        parent_method = getattr(super_class, method.__name__, None)
+        if parent_method is None:
+            continue
+        found = True
+        if not getattr(parent_method, "__allow_any_override__", False):
+            return True
+
+    if not found:
+        raise TypeError(
+            f"'{method.__qualname__}' does not override any method in its "
+            f"base classes. Remove @override or check the method name."
+        )
+
+    return False
+
+
+def allow_any_override(method: F) -> F:
+    """Mark an abstract method as permitting override with any signature.
+
+    Place this on base class methods where subclasses are expected to narrow
+    the signature (e.g. ``**kwargs`` → specific parameters). Without this
+    marker, ``@override`` would reject the signature change as an LSP
+    violation.
+
+    This is a marker only — it sets ``__allow_any_override__ = True`` on the
+    method. The check is performed by the ``@override`` decorator in this
+    module at class-creation time.
+
+    Args:
+        method: The abstract method to mark.
+
+    Returns:
+        The same method, with ``__allow_any_override__ = True`` set.
+
+    Examples:
+        Mark a base method::
+
+            class Base(EnforceOverrides):
+                @abstractmethod
+                @allow_any_override
+                def __call__(self, **kwargs) -> Any: ...
+
+        Subclass freely narrows the signature::
+
+            class Child(Base):
+                @override
+                def __call__(self, text: str, max_tokens: int = 512) -> str:
+                    ...
+    """
+    method.__allow_any_override__ = True  # type: ignore[attr-defined]
+    return method
+
+
+def override(method: F) -> F:
+    """Override decorator that respects ``@allow_any_override`` on parent methods.
+
+    Drop-in replacement for ``@override`` from the ``overrides`` library.
+    Behaviour:
+    - If the parent method has ``@allow_any_override``: installs the override
+      without signature validation.
+    - Otherwise: delegates to vanilla ``_overrides`` with full signature
+      checking.
+
+    Resolution happens at class-body execution time via the ``overrides``
+    library's ``_get_base_classes`` frame introspection.
+
+    Args:
+        method: The overriding method.
+
+    Returns:
+        The method, marked with ``__override__ = True``.
+
+    Raises:
+        TypeError: If ``method`` does not override any parent method.
+
+    Examples:
+        Narrowing a signature (allowed because parent has @allow_any_override)::
+
+            class Summarizer(Quant):
+                @override
+                def __call__(self, text: str, max_tokens: int = 512) -> str:
+                    ...
+
+        Normal override with signature enforcement::
+
+            class Summarizer(Quant):
+                @override
+                def dummy_inputs(self) -> list[dict[str, Any]]:
+                    return [{"text": "hello"}]
+    """
+    method.__override__ = True  # type: ignore[attr-defined]
+    if _should_enforce_signature(method):
+        _overrides(method, check_signature=True, check_at_runtime=False)
+    return method
+
+
+__all__ = ["allow_any_override", "override", "final", "EnforceOverrides"]

reqm/quant.py

@@ -0,0 +1,120 @@
+"""
+quant.py — The Quant abstract base class.
+
+A Quant is the unit reqm builds and manages: a callable with constructor args
+defined in config, and a dummy_inputs method that makes it auditable.
+"""
+
+import abc
+
+from reqm.overrides_ext import EnforceOverrides, allow_any_override
+
+
+class Quant(abc.ABC, EnforceOverrides):
+    """Abstract base class for all reqm Quants.
+
+    A Quant is a callable unit managed by reqm. It is:
+
+    - **Callable** — invoked directly with its inputs via ``__call__``
+    - **Config-driven** — constructor arguments defined in YAML, not hardcoded
+    - **Auditable** — ``dummy_inputs()`` provides example inputs that reqm uses
+      to verify the Quant actually runs at build time, not silently at inference
+
+    Subclasses must implement:
+
+    - ``__call__(**kwargs)`` — narrowed to the specific input signature
+    - ``dummy_inputs()`` — returns a list of input dicts, each ``**``-expandable
+      into ``__call__``
+
+    Examples:
+        Define a Quant::
+
+            from reqm import Quant
+            from reqm.overrides_ext import override
+
+            class Summarizer(Quant):
+                def __init__(self, model_name: str, max_tokens: int):
+                    self.model = load_model(model_name)
+                    self.max_tokens = max_tokens
+
+                @override
+                def __call__(self, text: str) -> str:
+                    return self.model.summarize(text, max_tokens=self.max_tokens)
+
+                @override
+                def dummy_inputs(self) -> list[dict[str, Any]]:
+                    return [
+                        {"text": "The quick brown fox."},
+                        {"text": "Short."},
+                    ]
+
+        reqm calls ``dummy_inputs`` at build time::
+
+            for inputs in quant.dummy_inputs():
+                quant(**inputs)  # fails fast here if something is broken
+    """
+
+    @abc.abstractmethod
+    @allow_any_override
+    def __call__(self, **kwargs) -> object:
+        """Call the Quant with the given inputs.
+
+        Subclasses must override this with their specific input signature.
+        The base signature is ``**kwargs`` to allow any narrowing — see
+        ``allow_any_override`` for why this is intentional.
+
+        Args:
+            **kwargs: Inputs to the Quant. The actual parameters are defined
+                by the subclass.
+
+        Returns:
+            The Quant's output. Type is defined by the subclass.
+
+        Examples:
+            Subclass narrowing the signature::
+
+                class Greeter(Quant):
+                    @override
+                    def __call__(self, name: str) -> str:
+                        return f"Hello, {name}!"
+
+            Calling the Quant::
+
+                greeter = reqm.get("greeter/friendly")
+                result = greeter(name="world")
+        """
+        ...
+
+    @abc.abstractmethod
+    def dummy_inputs(self) -> list[dict[str, object]]:
+        """Return a list of example input dicts for build-time sanity checking.
+
+        Each dict maps argument names to example values. reqm ``**``-expands
+        each dict into ``__call__`` when building the Quant. If any call fails,
+        the error is raised immediately with context — fail fast, not in prod.
+
+        Multiple dicts are encouraged: cover the happy path and edge cases.
+        These also serve as living documentation of valid call signatures.
+
+        Returns:
+            A non-empty list of dicts, each ``**``-expandable into ``__call__``.
+
+        Raises:
+            NotImplementedError: If not implemented by the subclass.
+
+        Examples:
+            Single input set::
+
+                def dummy_inputs(self) -> list[dict[str, Any]]:
+                    return [{"text": "The quick brown fox."}]
+
+            Multiple input sets (recommended — covers more call patterns)::
+
+                def dummy_inputs(self) -> list[dict[str, Any]]:
+                    return [
+                        {"text": "Short text."},
+                        {"text": "A longer piece of text to summarize properly."},
+                        {"text": "Edge case: single word."},
+                    ]
+        """
+        ...

reqm/quant_manager.py

@@ -0,0 +1,264 @@
+"""
+quant_manager.py — Directory-based config management for reqm.
+
+QuantManager takes an importable Python module (a directory with ``__init__.py``
+and YAML config files) and treats its filesystem root as a Hydra config search
+path. It provides methods to list, validate, load, and instantiate configs.
+"""
+
+from __future__ import annotations
+
+import types
+from pathlib import Path
+
+from hydra import compose, initialize_config_dir
+from hydra.core.global_hydra import GlobalHydra
+from hydra.utils import instantiate
+from omegaconf import DictConfig, OmegaConf
+
+
+class ConfigValidationError(Exception):
+    """Raised when a config file fails validation.
+
+    Includes the config path and a description of what failed, so the user
+    knows exactly which file to fix and what to change.
+
+    Args:
+        message: Human-readable description of the validation failure.
+
+    Examples:
+        Raised when ``# @package _global_`` is missing::
+
+            raise ConfigValidationError(
+                "Config 'model_a' at /path/to/model_a.yaml is missing the "
+                "required '# @package _global_' header. Add it as the first "
+                "line of the file."
+            )
+    """
+
+
+class QuantManager:
+    """Directory-based config manager built on Hydra.
+
+    Takes an importable Python config module and uses its directory as the
+    Hydra config root. Provides a uniform API to list, validate, load, and
+    build objects from YAML configs.
+
+    Args:
+        config_module: An imported Python module whose directory contains
+            YAML config files. Must be a real module with a ``__path__``
+            or ``__file__`` attribute.
+
+    Raises:
+        TypeError: If *config_module* is not a Python module.
+
+    Examples:
+        Create a QuantManager from a config module::
+
+            import my_configs
+            from reqm import QuantManager
+
+            QM = QuantManager(my_configs)
+            QM.list_configs()        # ["model_a", "sub/model_b"]
+            cfg = QM.get_config("model_a")
+            obj = QM.build("model_a")
+    """
+
+    def __init__(self, config_module: types.ModuleType) -> None:
+        if not isinstance(config_module, types.ModuleType):
+            raise TypeError(
+                f"Expected an imported Python module, got "
+                f"{type(config_module).__name__}. Pass the module object "
+                f"itself (e.g. `import my_configs; QuantManager(my_configs)`)."
+            )
+
+        if hasattr(config_module, "__path__"):
+            self._config_dir = Path(config_module.__path__[0]).resolve()
+        elif hasattr(config_module, "__file__") and config_module.__file__ is not None:
+            self._config_dir = Path(config_module.__file__).resolve().parent
+        else:
+            raise TypeError(
+                f"Module {config_module.__name__!r} has no __path__ or __file__ "
+                f"attribute. Cannot determine config directory."
+            )
+
+    def _resolve_config_path(self, config_name: str) -> Path:
+        """Return the absolute path to a config's YAML file, or raise."""
+        yaml_path = self._config_dir / f"{config_name}.yaml"
+        if not yaml_path.is_file():
+            raise FileNotFoundError(
+                f"Config '{config_name}' not found in config module "
+                f"at {self._config_dir}. "
+                f"Available configs: {self.list_configs()}"
+            )
+        return yaml_path
+
+    def list_configs(self) -> list[str]:
+        """List all YAML config names in the config module.
+
+        Recursively walks the config module directory and returns config
+        names (relative paths without the ``.yaml`` extension), sorted
+        alphabetically.
+
+        Returns:
+            Sorted list of config name strings.
+
+        Examples:
+            >>> QM = QuantManager(my_configs)
+            >>> QM.list_configs()
+            ['model_a', 'model_b', 'serving/prod', 'serving/staging']
+        """
+        return sorted(
+            str(p.relative_to(self._config_dir).with_suffix("")).replace("\\", "/")
+            for p in self._config_dir.rglob("*.yaml")
+        )
+
+    def validate(self, config_name: str | None = None) -> None:
+        """Validate that configs have the required ``# @package _global_`` header.
+
+        If *config_name* is provided, validates only that config. If ``None``,
+        validates every YAML file in the config module.
+
+        Args:
+            config_name: Optional config name to validate. If ``None``,
+                validates all configs.
+
+        Raises:
+            ConfigValidationError: If a config is missing
+                ``# @package _global_``.
+            FileNotFoundError: If *config_name* does not correspond to a
+                YAML file in the config module.
+
+        Examples:
+            Validate a single config::
+
+                QM.validate("model_a")  # raises if invalid
+
+            Validate all configs at once::
+
+                QM.validate()  # checks every YAML in the module
+        """
+        names = [config_name] if config_name is not None else self.list_configs()
+        for name in names:
+            yaml_path = self._resolve_config_path(name)
+            content = yaml_path.read_text(encoding="utf-8")
+            if "# @package _global_" not in content:
+                raise ConfigValidationError(
+                    f"Config '{name}' at {yaml_path} is missing the required "
+                    f"'# @package _global_' header. Add it as the first line "
+                    f"of the file."
+                )
+
+    def get_config(
+        self,
+        config_name: str,
+        *,
+        config_overrides: dict | DictConfig | None = None,
+        param_overrides: list[str] | None = None,
+    ) -> DictConfig:
+        """Load and fully resolve a config by name.
+
+        Composes the config via Hydra, applies overrides, resolves all
+        interpolations, and returns the result as an OmegaConf ``DictConfig``.
+
+        Args:
+            config_name: Config name (relative path, no ``.yaml`` extension).
+            config_overrides: Optional dict or ``DictConfig`` merged on top
+                of the composed config.
+            param_overrides: Optional list of Hydra CLI-style override strings
+                (e.g. ``["key=val", "nested.key=123"]``).
+
+        Returns:
+            Fully resolved ``DictConfig``.
+
+        Raises:
+            FileNotFoundError: If *config_name* does not exist.
+            omegaconf.errors.MissingMandatoryValue: If an interpolation
+                cannot be resolved.
+
+        Examples:
+            >>> cfg = QM.get_config("model_a")
+            >>> cfg = QM.get_config("model_a", param_overrides=["lr=0.01"])
+            >>> cfg = QM.get_config("model_a", config_overrides={"lr": 0.01})
+        """
+        self._resolve_config_path(config_name)
+
+        GlobalHydra.instance().clear()
+        with initialize_config_dir(config_dir=str(self._config_dir), version_base=None):
+            cfg = compose(config_name=config_name, overrides=param_overrides or [])
+        if config_overrides is not None:
+            OmegaConf.set_struct(cfg, False)
+            cfg = OmegaConf.merge(cfg, config_overrides)
+        OmegaConf.resolve(cfg)
+        return cfg
+
+    def get_raw_config(
+        self,
+        config_name: str,
+        *,
+        config_overrides: dict | DictConfig | None = None,
+        param_overrides: list[str] | None = None,
+    ) -> str:
+        """Load, resolve, and return a config as a YAML string.
+
+        Equivalent to calling :meth:`get_config` and serializing the result
+        via ``OmegaConf.to_yaml``.
+
+        Args:
+            config_name: Config name (relative path, no ``.yaml`` extension).
+            config_overrides: Optional dict or ``DictConfig`` merged on top.
+            param_overrides: Optional Hydra CLI-style override strings.
+
+        Returns:
+            The resolved config serialized as a YAML string.
+
+        Examples:
+            >>> yaml_str = QM.get_raw_config("model_a")
+            >>> print(yaml_str)
+            _target_: my_module.ModelA
+            lr: 0.001
+        """
+        cfg = self.get_config(
+            config_name,
+            config_overrides=config_overrides,
+            param_overrides=param_overrides,
+        )
+        return OmegaConf.to_yaml(cfg)
+
+    def build(
+        self,
+        config_name: str,
+        *,
+        config_overrides: dict | DictConfig | None = None,
+        param_overrides: list[str] | None = None,
+    ) -> object:
+        """Build an object from a config via ``hydra.utils.instantiate``.
+
+        Loads the config with :meth:`get_config`, then passes it to Hydra's
+        recursive instantiation. Returns whatever ``_target_`` points to.
+
+        This is a generic instantiator — it does **not** require the result
+        to be a :class:`~reqm.quant.Quant` subclass.
+
+        Args:
+            config_name: Config name (relative path, no ``.yaml`` extension).
+            config_overrides: Optional dict or ``DictConfig`` merged on top.
+            param_overrides: Optional Hydra CLI-style override strings.
+
+        Returns:
+            The instantiated object.
+
+        Raises:
+            FileNotFoundError: If *config_name* does not exist.
+            hydra.errors.InstantiationException: If instantiation fails.
+
+        Examples:
+            >>> obj = QM.build("model_a")
+            >>> obj = QM.build("model_a", param_overrides=["lr=0.01"])
+        """
+        cfg = self.get_config(
+            config_name,
+            config_overrides=config_overrides,
+            param_overrides=param_overrides,
+        )
+        return instantiate(cfg)

reqm-0.1.0.dist-info/METADATA

@@ -0,0 +1,256 @@
+Metadata-Version: 2.4
+Name: reqm
+Version: 0.1.0
+Summary: Ridiculously Easy Quant Manager — config-based aliased object factory with enforced interfaces
+Project-URL: Homepage, https://github.com/jkvc/reqm
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: hydra-core>=1.3
+Requires-Dist: overrides>=7.7.0
+Description-Content-Type: text/markdown
+
+# reqm
+
+**R**idiculously **E**asy **Q**uant **M**anager
+
+Directory-based config management and object factory built on [Hydra](https://hydra.cc).
+
+---
+
+## The problem
+
+Hydra is excellent for config-driven instantiation. But using it as a general object factory requires ceremony:
+
+```python
+# You have to do all of this just to instantiate one object
+with hydra.initialize(config_path="conf"):
+    cfg = hydra.compose(config_name="my_model")
+    model = hydra.utils.instantiate(cfg.model)
+```
+
+This ceremony means Hydra stays in the lab. It's awkward in a notebook, verbose in a service, and doesn't belong in production call sites.
+
+`reqm` gives you Hydra's power — config-driven instantiation, composable overrides, recursive object graphs — with none of the ceremony:
+
+```python
+from reqm import QuantManager
+import my_configs
+
+QM = QuantManager(my_configs)
+model = QM.build("summarizer_prod")
+```
+
+Same call in a notebook, a FastAPI endpoint, a test, or a batch job.
+
+---
+
+## Core concept: the Quant
+
+A **Quant** is the unit reqm builds and manages. It is:
+
+- **Callable** — invoked directly with its inputs
+- **Config-driven** — constructor arguments defined in YAML, no hardcoding
+- **Auditable** — implements `dummy_inputs()`, example inputs the factory uses to verify it actually runs
+
+```python
+from reqm import Quant
+from reqm.overrides_ext import override
+
+class Summarizer(Quant):
+    def __init__(self, model_name: str, max_tokens: int):
+        self.model = load_model(model_name)
+        self.max_tokens = max_tokens
+
+    @override
+    def dummy_inputs(self) -> list[dict]:
+        return [{"text": "The quick brown fox jumps over the lazy dog."}]
+
+    @override
+    def __call__(self, text: str) -> str:
+        return self.model.summarize(text, max_tokens=self.max_tokens)
+```
+
+The `dummy_inputs` contract is what separates a Quant from a plain ABC. reqm can call each Quant with its own dummy inputs at build time — if it fails, it fails early and loudly, not silently in production.
+
+---
+
+## Config modules and QuantManager
+
+A **config module** is any importable Python package containing YAML files:
+
+```
+my_configs/
+├── __init__.py
+├── summarizer_prod.yaml
+├── summarizer_fast.yaml
+└── serving/
+    └── prod.yaml
+```
+
+Each YAML config declares what to build:
+
+```yaml
+# @package _global_
+_target_: myproject.models.Summarizer
+model_name: gpt-4o
+max_tokens: 512
+```
+
+`QuantManager` takes the config module and gives you a uniform API. Construct it once in the `__init__.py` next to your configs directory, then import `QM` everywhere:
+
+```python
+# myproject/__init__.py (next to configs/)
+import myproject.configs as configs
+from reqm import QuantManager
+
+QM = QuantManager(configs)
+```
+
+```python
+# Any call site — notebook, script, service, test
+from myproject import QM
+
+QM.list_configs()          # ["serving/prod", "summarizer_fast", "summarizer_prod"]
+QM.validate()              # check all configs have # @package _global_
+cfg = QM.get_config("summarizer_prod")   # resolved OmegaConf DictConfig
+obj = QM.build("summarizer_prod")        # instantiated object
+```
+
+Configs can compose other configs via Hydra defaults lists:
+
+```yaml
+# @package _global_
+defaults:
+  - /base_model@child
+  - _self_
+_target_: myproject.models.Ensemble
+weight: 0.6
+```
+
+---
+
+## The uniform call site
+
+The core value proposition: ONE script, swap the config name, get different experimental results. No code changes, no if/else chains, no factory functions.
+
+Construct `QM` once in the `__init__.py` right next to your configs directory:
+
+```python
+# myproject/__init__.py (lives next to configs/)
+import myproject.configs as configs
+from reqm import QuantManager
+
+QM = QuantManager(configs)
+```
+
+Then every script just imports it:
+
+```python
+import sys
+from myproject import QM
+
+model = QM.build(sys.argv[1])       # <-- only this string changes
+result = model(text="Hello world")
+```
+
+```bash
+python evaluate.py summarizer_prod
+python evaluate.py summarizer_fast
+python evaluate.py summarizer_experiment_v3
+```
+
+---
+
+## Runnable example
+
+The repo includes a complete example project at `examples/estimators/` that demonstrates Quant subclasses, non-Quant configurable dependencies (Filters), Hydra config composition, and multiple scripts sharing a single `QM` instance defined in `examples/estimators/__init__.py`:
+
+```bash
+# Evaluate a single estimator config
+uv run python -m examples.estimators.scripts.evaluate mean_simple
+
+# Inspect the fully resolved config YAML
+uv run python -m examples.estimators.scripts.inspect_config ensemble/mean_median
+
+# Compare multiple configs side by side
+uv run python -m examples.estimators.scripts.compare mean_simple mean_outlier median_simple
+
+# Validate all configs
+uv run python -m examples.estimators.scripts.validate_configs
+
+# Sweep all configs and rank by performance
+uv run python -m examples.estimators.scripts.sweep
+```
+
+---
+
+## PyTorch integration
+
+reqm does not depend on PyTorch, but its primary use case is config-driven model experimentation with `nn.Module`. The repo includes a `TorchQuant` bridge class that resolves the `__call__` vs `forward()` conflict — subclass it instead of plain `Quant` when your model is an `nn.Module`:
+
+Don't subclass TorchQuant directly for every model — create a **domain base class** that locks the `forward` signature for your use case:
+
+```python
+from myproject.torch_quant import TorchQuant  # copy from examples/
+
+# Domain base — locks forward(self, x: Tensor) -> Tensor for all regressors
+class Regressor(TorchQuant):
+    in_features: int
+
+    @override
+    @abc.abstractmethod
+    def forward(self, x: torch.Tensor) -> torch.Tensor: ...
+
+    @override
+    def dummy_inputs(self) -> list[dict]:
+        return [{"x": torch.randn(4, self.in_features)}]
+
+
+# Concrete model — must match the Regressor signature
+class LinearRegressor(Regressor):
+    def __init__(self, in_features: int):
+        super().__init__()
+        self.in_features = in_features
+        self.linear = nn.Linear(in_features, 1)
+
+    @override
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.linear(x)
+```
+
+`TorchQuant.forward` uses `@allow_any_override` so domain bases can narrow freely. Once the domain base locks the signature (without `@allow_any_override`), all concrete models must match — enforced at class definition time, not runtime.
+
+See `docs/torch_integration.md` for the full explanation, and `examples/torch_models/` for a runnable example:
+
+```bash
+uv run python -m examples.torch_models.scripts.evaluate linear_simple
+uv run python -m examples.torch_models.scripts.evaluate mlp_small
+uv run python -m examples.torch_models.scripts.audit
+```
+
+---
+
+## Why not just Hydra?
+
+Hydra is framework-first. It expects to own your program's entry point. `reqm` is library-first — it has no opinion about your application structure and works wherever Python runs.
+
+| | Hydra | reqm |
+|---|---|---|
+| Object instantiation | yes | yes |
+| Config composition | yes | yes (via Hydra) |
+| Auditability (`dummy_inputs`) | no | yes |
+| Works in notebooks | limited | yes |
+| CLI ceremony required | yes | no |
+
+---
+
+## Name
+
+`reqm` is also a nod to [Rue Esquermoise](https://en.wikipedia.org/wiki/Rue_Esquermoise), one of the oldest streets in Lille, France, dating to the 13th century. Its etymology traces to the Flemish *eskelm* — "frontier." A fitting name for a library that sits at the frontier between research and production.
+
+---
+
+## Status
+
+Core API implemented: `Quant`, `QuantManager`, config composition, and override support all work. See `examples/estimators/` for a complete working project.

reqm-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+reqm/__init__.py,sha256=UJmu6qNyiYLzKhaumRQ70NKxVZaHOi3RYDrx6mwy_Kk,202
+reqm/overrides_ext.py,sha256=0_QWmf9r0eonsyjK3c6VaY3m6r_YpuNbbi6851278Zg,5671
+reqm/quant.py,sha256=ZdvfHl-PLdKp2EvageR5GtU39jC_aOfnr2qWmOlktKw,4179
+reqm/quant_manager.py,sha256=ng39ksSXRZPsrwop-DY-HSFqvLSSHmmvWNeDnsxcnIE,9633
+reqm-0.1.0.dist-info/METADATA,sha256=059nNsulphQIQUN_K-XieLgI2IkjleBf7xC-ejU10co,8031
+reqm-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+reqm-0.1.0.dist-info/licenses/LICENSE,sha256=HXnpKXLs5Z7H4V7nPUlUXb0L4_HQ_Q66xvm5xn45rOY,1061
+reqm-0.1.0.dist-info/RECORD,,

reqm-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

reqm-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 jkvc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.