invarlock 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

invarlock/__init__.py

@@ -1,5 +1,5 @@
 """
-InvarLock: Edit‑agnostic robustness certificates for weight edits
+InvarLock: Edit‑agnostic evaluation reports for weight edits
 =============================================================
 
 Core runtime package — torch-independent utilities, configuration, and interfaces.
@@ -9,10 +9,10 @@ For torch-dependent functionality, see subpackages under `invarlock.*`:
 - `invarlock.adapters`: Model adapters (HF causal/MLM/seq2seq + auto)
 - `invarlock.guards`: Safety mechanisms (invariants, spectral, RMT, variance)
 - `invarlock.edits`: Built-in quantization and edit interfaces
-- `invarlock.eval`: Metrics, guard-overhead checks, and certification
+- `invarlock.eval`: Metrics, guard-overhead checks, and evaluation reporting
 """
 
-__version__ = "0.3.7"
+__version__ = "0.3.9"
 
 # Core exports - torch-independent
 from .config import CFG, Defaults, get_default_config

invarlock/adapters/auto.py

@@ -38,11 +38,7 @@ def _detect_quantization_from_path(model_id: str) -> str | None:
             return "hf_awq"
         elif quant_method == "gptq":
             return "hf_gptq"
-        elif (
-            quant_method == "bitsandbytes"
-            or quant_cfg.get("load_in_8bit")
-            or quant_cfg.get("load_in_4bit")
-        ):
+        elif "bitsandbytes" in quant_method or "bnb" in quant_method:
             return "hf_bnb"
 
     except Exception:
@@ -78,11 +74,7 @@ def _detect_quantization_from_model(model: Any) -> str | None:
             return "hf_awq"
         elif quant_method == "gptq":
             return "hf_gptq"
-        elif (
-            quant_method == "bitsandbytes"
-            or quant_cfg.get("load_in_8bit")
-            or quant_cfg.get("load_in_4bit")
-        ):
+        elif "bitsandbytes" in quant_method or "bnb" in quant_method:
             return "hf_bnb"
     else:
         # Object-style config

invarlock/adapters/hf_loading.py

@@ -50,7 +50,7 @@ def resolve_trust_remote_code(
     return default
 
 
-def default_torch_dtype() -> torch.dtype:
+def default_dtype() -> torch.dtype:
     """Pick a safe default dtype for HF loads based on hardware."""
     if torch.cuda.is_available():
         try:
@@ -69,10 +69,10 @@ def default_torch_dtype() -> torch.dtype:
     return torch.float32
 
 
-def resolve_torch_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | str:
-    """Resolve torch_dtype from kwargs or choose a hardware-aware default."""
-    if kwargs and "torch_dtype" in kwargs:
-        val = kwargs.get("torch_dtype")
+def resolve_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | str:
+    """Resolve dtype from kwargs or choose a hardware-aware default."""
+    if kwargs and "dtype" in kwargs:
+        val = kwargs.get("dtype")
         if isinstance(val, torch.dtype):
             return val
         if isinstance(val, str):
@@ -91,7 +91,7 @@ def resolve_torch_dtype(kwargs: dict[str, Any] | None = None) -> torch.dtype | s
             if s in mapping:
                 return mapping[s]
 
-    return default_torch_dtype()
+    return default_dtype()
 
 
-__all__ = ["resolve_trust_remote_code", "default_torch_dtype", "resolve_torch_dtype"]
+__all__ = ["resolve_trust_remote_code", "default_dtype", "resolve_dtype"]

invarlock/adapters/hf_mixin.py

@@ -583,22 +583,45 @@ class HFAdapterMixin:
     def _serialize_config(self, config: Any) -> dict[str, Any]:
         """Serialize HuggingFace config fields into simple Python types."""
 
+        def _collect(data: dict[str, Any]) -> dict[str, Any]:
+            out: dict[str, Any] = {}
+            for key, value in data.items():
+                if key.startswith("_") or key in {"method_calls"}:
+                    continue
+                if value is None or isinstance(value, SCALAR_TYPES):
+                    out[key] = value
+                elif isinstance(value, list | dict):
+                    out[key] = value
+            return out
+
+        to_dict = getattr(config, "to_dict", None)
+        if callable(to_dict):
+            try:
+                data = to_dict()
+            except Exception:
+                data = None
+            if isinstance(data, dict):
+                return _collect(data)
+
+        try:
+            data = vars(config)
+        except TypeError:
+            data = None
+        if isinstance(data, dict):
+            return _collect(data)
+
         result: dict[str, Any] = {}
         for key in dir(config):
-            if key.startswith("_"):
+            if key.startswith("_") or key in {"torch_dtype"}:
                 continue
-
             try:
                 value = getattr(config, key)
             except AttributeError:
                 continue
-
             if callable(value):
                 continue
-
             if value is None or isinstance(value, SCALAR_TYPES):
                 result[key] = value
             elif isinstance(value, list | dict):
                 result[key] = value
-
         return result

invarlock/assurance/__init__.py

@@ -1,8 +1,4 @@
-"""Assurance namespace (`invarlock.assurance`).
-
-This namespace groups safety-certificate related surfaces. For now it forwards
-to `invarlock.eval` and guard modules; future work may move implementations here.
-"""
+"""Assurance namespace (`invarlock.assurance`)."""
 
 from __future__ import annotations
 
@@ -11,33 +7,29 @@ from typing import Any
 from invarlock.reporting.report_types import RunReport
 
 try:  # pragma: no cover - shim to reporting modules
-    from invarlock.reporting.certificate import (
-        CERTIFICATE_SCHEMA_VERSION,
-        make_certificate,
-        validate_certificate,
-    )
-
     # Prefer direct import from render for rendering APIs
-    from invarlock.reporting.render import render_certificate_markdown
+    from invarlock.reporting.render import render_report_markdown
+    from invarlock.reporting.report_builder import make_report
+    from invarlock.reporting.report_schema import REPORT_SCHEMA_VERSION, validate_report
 except Exception:  # pragma: no cover - provide soft stubs
-    CERTIFICATE_SCHEMA_VERSION = "v1"
+    REPORT_SCHEMA_VERSION = "v1"
 
-    def make_certificate(
+    def make_report(
         report: RunReport,
         baseline: RunReport | dict[str, Any],
     ) -> dict[str, Any]:
-        raise ImportError("invarlock.reporting.certificate not available")
+        raise ImportError("invarlock.reporting.report_builder not available")
 
-    def render_certificate_markdown(certificate: dict[str, Any]) -> str:
-        raise ImportError("invarlock.reporting.certificate not available")
+    def render_report_markdown(evaluation_report: dict[str, Any]) -> str:
+        raise ImportError("invarlock.reporting.report_builder not available")
 
-    def validate_certificate(certificate: dict[str, Any]) -> bool:
-        raise ImportError("invarlock.reporting.certificate not available")
+    def validate_report(report: dict[str, Any]) -> bool:
+        raise ImportError("invarlock.reporting.report_schema not available")
 
 
 __all__ = [
-    "CERTIFICATE_SCHEMA_VERSION",
-    "make_certificate",
-    "render_certificate_markdown",
-    "validate_certificate",
+    "REPORT_SCHEMA_VERSION",
+    "make_report",
+    "render_report_markdown",
+    "validate_report",
 ]

invarlock/calibration/spectral_null.py

@@ -35,7 +35,7 @@ def _bh_reject_families(
 
     order = sorted(
         range(n),
-        key=lambda idx: (float("inf") if not _finite01(pvals[idx]) else pvals[idx]),
+        key=lambda idx: float("inf") if not _finite01(pvals[idx]) else pvals[idx],
     )
     max_k = 0
     for rank, idx in enumerate(order, start=1):

invarlock/cli/adapter_auto.py

@@ -47,11 +47,7 @@ def _detect_quant_family_from_cfg(cfg: dict[str, Any]) -> str | None:
                 return "hf_gptq"
             if any(tok in method for tok in ("awq",)):
                 return "hf_awq"
-            # BitsAndBytes style
-            if any(
-                str(q.get(k, "")).lower() in {"true", "1"}
-                for k in ("load_in_4bit", "load_in_8bit")
-            ) or any("bitsandbytes" in str(v).lower() for v in q.values()):
+            if "bitsandbytes" in method or "bnb" in method:
                 return "hf_bnb"
     except Exception:
         return None

invarlock/cli/app.py

@@ -17,7 +17,11 @@ import typer
 from rich.console import Console
 from typer.core import TyperGroup
 
-from invarlock.security import enforce_default_security
+from invarlock.security import (
+    enforce_default_security,
+    enforce_network_policy,
+    network_policy_allows,
+)
 
 # Lightweight import mode disables heavy side effects in some modules, but we no
 # longer force plugin discovery off globally here; individual commands may gate
@@ -33,7 +37,7 @@ LIGHT_IMPORT = os.getenv("INVARLOCK_LIGHT_IMPORT", "").strip().lower() in {
 class OrderedGroup(TyperGroup):
     def list_commands(self, ctx):  # type: ignore[override]
         return [
-            "certify",
+            "evaluate",
             "calibrate",
             "report",
             "verify",
@@ -48,8 +52,8 @@ class OrderedGroup(TyperGroup):
 app = typer.Typer(
     name="invarlock",
     help=(
-        "InvarLock — certify model changes with deterministic pairing and safety gates.\n"
-        "Quick path: invarlock certify --baseline <MODEL> --subject <MODEL>\n"
+        "InvarLock — evaluate model changes with deterministic pairing and safety gates.\n"
+        "Quick path: invarlock evaluate --baseline <MODEL> --subject <MODEL>\n"
         "Hint: use --edit-config to run the built-in quant_rtn demo.\n"
         "Tip: enable downloads with INVARLOCK_ALLOW_NETWORK=1 when fetching.\n"
         "Exit codes:\n"
@@ -65,17 +69,16 @@ app = typer.Typer(
 console = Console()
 
 
-@app.command()
-def version():
-    """Show InvarLock version."""
+def _emit_version() -> None:
+    """Emit the InvarLock version string."""
     # Prefer package metadata when available so CLI reflects wheel truth
     try:
         from importlib.metadata import version as _pkg_version
 
         schema = None
         try:
-            from invarlock.reporting.certificate import (
-                CERTIFICATE_SCHEMA_VERSION as _SCHEMA,
+            from invarlock.reporting.report_builder import (
+                REPORT_SCHEMA_VERSION as _SCHEMA,
             )
 
             schema = _SCHEMA
@@ -96,20 +99,45 @@ def version():
         console.print("InvarLock version unknown")
 
 
+@app.callback(invoke_without_command=True)
+def _root(
+    ctx: typer.Context,
+    show_version: bool = typer.Option(
+        False,
+        "--version",
+        "-V",
+        help="Show version and exit.",
+        is_eager=True,
+    ),
+) -> None:
+    was_allowed = network_policy_allows()
+    enforce_default_security()
+    ctx.call_on_close(lambda: enforce_network_policy(was_allowed))
+    if show_version:
+        _emit_version()
+        raise typer.Exit()
+
+
+@app.command()
+def version():
+    """Show InvarLock version."""
+    _emit_version()
+
+
 """Register command modules and groups in the desired help order.
 
-Order: certify → report → run → plugins → doctor → version
+Order: evaluate → report → run → plugins → doctor → version
 """
 
 
 @app.command(
-    name="certify",
+    name="evaluate",
     help=(
-        "Certify a subject model against a baseline and generate an evaluation certificate. "
+        "Evaluate a subject model against a baseline and generate an evaluation report. "
         "Use when you have two model snapshots and want pass/fail gating."
     ),
 )
-def _certify_lazy(
+def _evaluate_lazy(
     source: str = typer.Option(
         ..., "--source", "--baseline", help="Baseline model dir or Hub ID"
     ),
@@ -141,8 +169,8 @@ def _certify_lazy(
         ),
     ),
     out: str = typer.Option("runs", "--out", help="Base output directory"),
-    cert_out: str = typer.Option(
-        "reports/cert", "--cert-out", help="Certificate output directory"
+    report_out: str = typer.Option(
+        "reports/eval", "--report-out", help="Evaluation report output directory"
     ),
     edit_config: str | None = typer.Option(
         None, "--edit-config", help="Edit preset to apply a demo edit (quant_rtn)"
@@ -173,9 +201,9 @@ def _certify_lazy(
         False, "--no-color", help="Disable ANSI colors (respects NO_COLOR=1)"
     ),
 ):
-    from .commands.certify import certify_command as _cert
+    from .commands.evaluate import evaluate_command as _eval
 
-    return _cert(
+    return _eval(
         source=source,
         edited=edited,
         baseline_report=baseline_report,
@@ -185,7 +213,7 @@ def _certify_lazy(
         tier=tier,
         preset=preset,
         out=out,
-        cert_out=cert_out,
+        report_out=report_out,
         edit_config=edit_config,
         edit_label=edit_label,
         quiet=quiet,
@@ -226,18 +254,18 @@ def _register_subapps() -> None:
 @app.command(
     name="verify",
     help=(
-        "Verify certificate JSON(s) against schema, pairing math, and gates. "
+        "Verify evaluation report JSON(s) against schema, pairing math, and gates. "
         "Use --json for a single-line machine-readable envelope."
     ),
 )
 def _verify_typed(
-    certificates: list[str] = typer.Argument(
-        ..., help="One or more certificate JSON files to verify."
+    reports: list[str] = typer.Argument(
+        ..., help="One or more evaluation report JSON files to verify."
     ),
     baseline: str | None = typer.Option(
         None,
         "--baseline",
-        help="Optional baseline certificate/report JSON to enforce provider parity.",
+        help="Optional baseline evaluation report JSON to enforce provider parity.",
     ),
     tolerance: float = typer.Option(
         1e-9, "--tolerance", help="Tolerance for analysis-basis comparisons."
@@ -257,10 +285,10 @@ def _verify_typed(
 
     from .commands.verify import verify_command as _verify
 
-    cert_paths = [_Path(c) for c in certificates]
+    report_paths = [_Path(p) for p in reports]
     baseline_path = _Path(baseline) if isinstance(baseline, str) else None
     return _verify(
-        certificates=cert_paths,
+        reports=report_paths,
         baseline=baseline_path,
         tolerance=tolerance,
         profile=profile,
@@ -272,7 +300,7 @@ def _verify_typed(
     name="run",
     help=(
         "Execute an end-to-end run from a YAML config (edit + guards + reports). "
-        "Writes run artifacts and optionally an evaluation certificate."
+        "Writes run artifacts and optionally an evaluation report."
     ),
 )
 def _run_typed(
@@ -309,7 +337,9 @@ def _run_typed(
         None, "--probes", help="Number of micro-probes (0=deterministic, >0=adaptive)"
     ),
     until_pass: bool = typer.Option(
-        False, "--until-pass", help="Retry until certificate passes (max 3 attempts)"
+        False,
+        "--until-pass",
+        help="Retry until evaluation report passes gates (max 3 attempts)",
     ),
     max_attempts: int = typer.Option(
         3, "--max-attempts", help="Maximum retry attempts for --until-pass mode"
@@ -320,7 +350,7 @@ def _run_typed(
     baseline: str | None = typer.Option(
         None,
         "--baseline",
-        help="Path to baseline report.json for certificate validation",
+        help="Path to baseline report.json for evaluation report validation",
     ),
     no_cleanup: bool = typer.Option(
         False, "--no-cleanup", help="Skip cleanup of temporary artifacts"

invarlock/cli/commands/__init__.py

@@ -5,8 +5,8 @@ Import-time work is minimal; subcommands themselves may perform heavier imports
 only when invoked.
 """
 
-from .certify import certify_command
 from .doctor import doctor_command
+from .evaluate import evaluate_command
 from .explain_gates import explain_gates_command
 from .export_html import export_html_command
 from .plugins import plugins_command
@@ -15,7 +15,7 @@ from .run import run_command
 from .verify import verify_command
 
 __all__ = [
-    "certify_command",
+    "evaluate_command",
     "doctor_command",
     "explain_gates_command",
     "export_html_command",

invarlock/cli/commands/calibrate.py

@@ -20,10 +20,6 @@ import typer
 import yaml
 from rich.console import Console
 
-from invarlock.calibration.spectral_null import summarize_null_sweep_reports
-from invarlock.calibration.variance_ve import summarize_ve_sweep_reports
-from invarlock.guards.tier_config import get_tier_guard_config
-
 console = Console()
 
 calibrate_app = typer.Typer(
@@ -114,6 +110,26 @@ def _write_tiers_recommendation(
     )
 
 
+def get_tier_guard_config(tier: str, guard_key: str) -> dict[str, Any]:
+    """Lazy wrapper for tier config lookup.
+
+    This is intentionally a module-level symbol so tests can patch it without
+    importing torch/transformers at import time.
+    """
+    try:
+        from invarlock.guards.tier_config import get_tier_guard_config as _get_cfg
+    except ModuleNotFoundError as exc:
+        missing = getattr(exc, "name", "") or ""
+        if missing in {"torch", "transformers"}:
+            console.print(
+                "[red]Missing optional dependencies for calibration.[/red] "
+                "Install `invarlock[hf]` (or at least torch/transformers) to run sweeps."
+            )
+            raise typer.Exit(1) from exc
+        raise
+    return _get_cfg(tier, guard_key)
+
+
 @calibrate_app.command(
     name="null-sweep",
     help="Run a null (no-op edit) sweep and calibrate spectral κ/alpha empirically.",
@@ -160,6 +176,21 @@ def null_sweep(
     # Keep import light: only pull run machinery when invoked.
     from .run import run_command
 
+    # Optional deps: calibration sweeps require torch/guards, but docs/tests may
+    # import this module without heavy deps. Import lazily so CLI example
+    # validation can parse `invarlock calibrate ...` without installing torch.
+    try:
+        from invarlock.calibration.spectral_null import summarize_null_sweep_reports
+    except ModuleNotFoundError as exc:
+        missing = getattr(exc, "name", "") or ""
+        if missing in {"torch", "transformers"}:
+            console.print(
+                "[red]Missing optional dependencies for calibration.[/red] "
+                "Install `invarlock[hf]` (or at least torch/transformers) to run sweeps."
+            )
+            raise typer.Exit(1) from exc
+        raise
+
     base = _load_yaml(config)
     specs = _materialize_sweep_specs(
         tiers=tiers, seeds=seed, n_seeds=n_seeds, seed_start=seed_start
@@ -378,6 +409,19 @@ def ve_sweep(
     # Keep import light: only pull run machinery when invoked.
     from .run import run_command
 
+    # Optional deps: see null_sweep() note.
+    try:
+        from invarlock.calibration.variance_ve import summarize_ve_sweep_reports
+    except ModuleNotFoundError as exc:
+        missing = getattr(exc, "name", "") or ""
+        if missing in {"torch", "transformers"}:
+            console.print(
+                "[red]Missing optional dependencies for calibration.[/red] "
+                "Install `invarlock[hf]` (or at least torch/transformers) to run sweeps."
+            )
+            raise typer.Exit(1) from exc
+        raise
+
     base = _load_yaml(config)
     windows = [int(w) for w in (window or [])] or [6, 8, 12, 16]
     specs = _materialize_sweep_specs(