invarlock 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

invarlock/adapters/hf_mixin.py

@@ -4,10 +4,12 @@ Shared HuggingFace adapter mixin.
 
 Provides reusable functionality for InvarLock's HuggingFace adapters:
 - Device resolution helpers
+- Safe device movement for quantized models
 - Snapshot/restore with device awareness
 - Chunked snapshot helpers to reduce peak memory usage
 - Lightweight config serialization
 - Weight-tying detection plumbing
+- Quantization detection and capabilities
 """
 
 from __future__ import annotations
@@ -17,12 +19,15 @@ import json
 import os
 import tempfile
 from pathlib import Path
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import torch
 
 from invarlock.security import is_secure_path
 
+if TYPE_CHECKING:
+    from .capabilities import ModelCapabilities, QuantizationConfig
+
 SCALAR_TYPES = (int, float, str, bool)
 
 
@@ -91,6 +96,122 @@ class HFAdapterMixin:
 
         return torch.device(device_str)
 
+    def _safe_to_device(
+        self,
+        model: torch.nn.Module,
+        device: str | torch.device | None = "auto",
+        capabilities: ModelCapabilities | None = None,
+    ) -> torch.nn.Module:
+        """
+        Safely move model to device, respecting quantization constraints.
+
+        For quantized models (BNB, AWQ, GPTQ), device movement may be
+        impossible or already handled by the loading mechanism. This
+        method checks the model's capabilities before attempting .to().
+
+        Args:
+            model: The model to move.
+            device: Target device ("auto", "cuda", "mps", "cpu").
+            capabilities: Pre-computed capabilities, or None to auto-detect.
+
+        Returns:
+            The model (possibly on the new device, or unchanged if not movable).
+        """
+        target_device = self._resolve_device(device)
+
+        # Auto-detect capabilities if not provided
+        if capabilities is None:
+            capabilities = self._detect_capabilities(model)
+
+        # Check if model can be moved
+        if capabilities is not None and not capabilities.device_movable:
+            # Model handles its own device placement (e.g., BNB, AWQ, GPTQ)
+            # Log this decision for debugging but don't attempt .to()
+            return model
+
+        # Safe to move
+        return model.to(target_device)
+
+    def _detect_capabilities(self, model: torch.nn.Module) -> ModelCapabilities | None:
+        """
+        Detect model capabilities from a loaded model instance.
+
+        Args:
+            model: Loaded model instance.
+
+        Returns:
+            ModelCapabilities if detection succeeds, None otherwise.
+        """
+        try:
+            from .capabilities import detect_capabilities_from_model
+
+            return detect_capabilities_from_model(model)
+        except ImportError:
+            return None
+
+    def _is_quantized_model(self, model: torch.nn.Module) -> bool:
+        """
+        Check if a model is quantized (BNB, AWQ, GPTQ).
+
+        This is a quick heuristic check that doesn't require full
+        capability detection.
+
+        Args:
+            model: Model to check.
+
+        Returns:
+            True if the model appears to be quantized.
+        """
+        config = getattr(model, "config", None)
+        if config is None:
+            return False
+
+        # Check for quantization_config attribute
+        quant_cfg = getattr(config, "quantization_config", None)
+        if quant_cfg is not None:
+            return True
+
+        # Check for BNB-specific attributes on the model
+        if hasattr(model, "is_loaded_in_8bit") and model.is_loaded_in_8bit:
+            return True
+        if hasattr(model, "is_loaded_in_4bit") and model.is_loaded_in_4bit:
+            return True
+
+        # Check for quantized module types in the model
+        for module in model.modules():
+            module_name = module.__class__.__name__.lower()
+            if any(
+                q in module_name
+                for q in ["linear8bit", "linear4bit", "quantlinear", "awqlinear"]
+            ):
+                return True
+
+        return False
+
+    def _detect_quantization_config(
+        self, model: torch.nn.Module
+    ) -> QuantizationConfig | None:
+        """
+        Detect quantization configuration from a model.
+
+        Args:
+            model: Model to inspect.
+
+        Returns:
+            QuantizationConfig if quantization detected, None otherwise.
+        """
+        try:
+            from .capabilities import detect_quantization_from_config
+
+            config = getattr(model, "config", None)
+            if config is not None:
+                quant_cfg = detect_quantization_from_config(config)
+                if quant_cfg.is_quantized():
+                    return quant_cfg
+        except ImportError:
+            pass
+        return None
+
     # ------------------------------------------------------------------
     # HF save/export helpers
     # ------------------------------------------------------------------

invarlock/core/registry.py

@@ -117,14 +117,24 @@ class CoreRegistry:
             module: str,
             class_name: str,
             status: str = "Available (fallback)",
+            required_deps: list[str] | None = None,
         ) -> None:
             if name not in registry:
+                # Check runtime dependencies for optional plugins
+                actual_available = True
+                actual_status = status
+                if required_deps:
+                    missing = self._check_runtime_dependencies(required_deps)
+                    if missing:
+                        actual_available = False
+                        actual_status = f"Needs extra: {', '.join(missing)}"
+
                 registry[name] = PluginInfo(
                     name=name,
                     module=module,
                     class_name=class_name,
-                    available=True,
-                    status=status,
+                    available=actual_available,
+                    status=actual_status,
                     package="invarlock",
                     version=INVARLOCK_VERSION,
                 )
@@ -147,27 +157,30 @@ class CoreRegistry:
         _fallback(
             self._adapters, "hf_mlm_auto", "invarlock.adapters", "HF_MLM_Auto_Adapter"
         )
-        # Optional plugin adapters (available when modules present)
+        # Optional plugin adapters (verify runtime dependencies)
         _fallback(
             self._adapters,
             "hf_gptq",
             "invarlock.plugins.hf_gptq_adapter",
             "HF_GPTQ_Adapter",
-            status="Available (fallback plugin)",
+            status="Available (plugin)",
+            required_deps=["auto_gptq"],
         )
         _fallback(
             self._adapters,
             "hf_awq",
             "invarlock.plugins.hf_awq_adapter",
             "HF_AWQ_Adapter",
-            status="Available (fallback plugin)",
+            status="Available (plugin)",
+            required_deps=["autoawq"],
         )
         _fallback(
             self._adapters,
             "hf_bnb",
             "invarlock.plugins.hf_bnb_adapter",
             "HF_BNB_Adapter",
-            status="Available (fallback plugin)",
+            status="Available (plugin)",
+            required_deps=["bitsandbytes"],
         )
 
         # Register built-in edits (quant-only core) and internal no-op
@@ -181,6 +194,21 @@ class CoreRegistry:
         _fallback(self._guards, "rmt", "invarlock.guards", "RMTGuard")
         _fallback(self._guards, "hello_guard", "invarlock.plugins", "HelloGuard")
 
+    def _check_runtime_dependencies(self, deps: list[str]) -> list[str]:
+        """
+        Check if runtime dependencies are actually importable.
+
+        Returns:
+            List of missing dependency names.
+        """
+        missing = []
+        for dep in deps:
+            try:
+                importlib.import_module(dep)
+            except ImportError:
+                missing.append(dep)
+        return missing
+
     def _create_plugin_info(
         self, entry_point: EntryPoint, plugin_type: str
     ) -> PluginInfo:

invarlock/guards/variance.py

@@ -39,6 +39,30 @@ from .policies import VariancePolicyDict
 __all__ = ["equalise_residual_variance", "equalise_branch_variance", "VarianceGuard"]
 
 
+def _safe_mean(
+    samples: list[float] | np.ndarray, default: float | None = None
+) -> float | None:
+    """
+    Compute mean of samples, returning default if empty.
+
+    Avoids numpy RuntimeWarning "Mean of empty slice" when samples is empty
+    or contains no valid values.
+
+    Args:
+        samples: List or array of float values.
+        default: Value to return if samples is empty.
+
+    Returns:
+        Mean value or default if samples is empty.
+    """
+    if samples is None:
+        return default
+    arr = np.asarray(samples)
+    if arr.size == 0:
+        return default
+    return float(np.nanmean(arr))
+
+
 try:  # Optional dependency: tqdm (progress bars)
     from tqdm.auto import tqdm as _tqdm
 except Exception:  # pragma: no cover - exercised only when tqdm is absent
@@ -1472,7 +1496,14 @@ class VarianceGuard(Guard):
 
         if coverage >= min_coverage and not self._scales:
             ppl_no_ve_samples = ppl_no_ve_samples[:coverage]
-            ppl_no_ve_mean = float(np.mean(ppl_no_ve_samples))
+            ppl_no_ve_mean = _safe_mean(ppl_no_ve_samples)
+            if ppl_no_ve_mean is None:
+                # No valid samples - cannot compute mean
+                self._ratio_ci = None
+                predictive_state["reason"] = "no_valid_samples"
+                self._predictive_gate_state = predictive_state
+                self._stats["predictive_gate"] = predictive_state.copy()
+                return
             self.set_ab_results(
                 ppl_no_ve=ppl_no_ve_mean,
                 ppl_with_ve=ppl_no_ve_mean,
@@ -1527,8 +1558,12 @@ class VarianceGuard(Guard):
                     n_bootstrap=500,
                     seed=calib_seed,
                 )
-                ppl_no_ve_mean = float(np.mean(ppl_no_ve_samples))
-                ppl_with_ve_mean = float(np.mean(ppl_with_ve_samples))
+                ppl_no_ve_mean = _safe_mean(ppl_no_ve_samples)
+                ppl_with_ve_mean = _safe_mean(ppl_with_ve_samples)
+                if ppl_no_ve_mean is None or ppl_with_ve_mean is None:
+                    # Fallback if means couldn't be computed
+                    ppl_no_ve_mean = ppl_no_ve_mean or 0.0
+                    ppl_with_ve_mean = ppl_with_ve_mean or 0.0
                 self.set_ab_results(
                     ppl_no_ve=ppl_no_ve_mean,
                     ppl_with_ve=ppl_with_ve_mean,
@@ -2118,7 +2153,7 @@ class VarianceGuard(Guard):
 
                 if coverage >= min_coverage and not self._scales:
                     ppl_no_ve_samples = ppl_no_ve_samples[:coverage]
-                    ppl_no_ve_mean = float(np.mean(ppl_no_ve_samples))
+                    ppl_no_ve_mean = _safe_mean(ppl_no_ve_samples, default=0.0)
                     self.set_ab_results(
                         ppl_no_ve=ppl_no_ve_mean,
                         ppl_with_ve=ppl_no_ve_mean,
@@ -2158,8 +2193,8 @@ class VarianceGuard(Guard):
                             n_bootstrap=500,
                             seed=calib_seed,
                         )
-                        ppl_no_ve_mean = float(np.mean(ppl_no_ve_samples))
-                        ppl_with_ve_mean = float(np.mean(ppl_with_ve_samples))
+                        ppl_no_ve_mean = _safe_mean(ppl_no_ve_samples, default=0.0)
+                        ppl_with_ve_mean = _safe_mean(ppl_with_ve_samples, default=0.0)
                         self.set_ab_results(
                             ppl_no_ve=ppl_no_ve_mean,
                             ppl_with_ve=ppl_with_ve_mean,

invarlock/plugins/hf_awq_adapter.py

@@ -4,12 +4,16 @@ HuggingFace AWQ Adapter (plugin)
 
 Optional adapter for loading AWQ-quantized causal LMs from the Hub.
 Requires the `autoawq` extra on supported platforms (typically Linux/CUDA).
+
+AWQ models are pre-quantized and typically handle device placement internally
+during loading. This adapter does NOT call .to() on the loaded model.
 """
 
 from __future__ import annotations
 
 from typing import Any
 
+from invarlock.adapters.capabilities import ModelCapabilities
 from invarlock.adapters.hf_mixin import HFAdapterMixin
 from invarlock.core.api import ModelAdapter
 from invarlock.core.error_utils import wrap_errors
@@ -56,7 +60,24 @@ class HF_AWQ_Adapter(HFAdapterMixin, ModelAdapter):
                 trust_remote_code=True,
                 **{k: v for k, v in kwargs.items() if k != "device"},
             )
-        return model.to(self._resolve_device(device))
+
+        # AWQ models are pre-quantized; use safe device movement
+        # which respects the model's device constraints
+        return self._safe_to_device(
+            model, device, capabilities=ModelCapabilities.for_awq()
+        )
+
+    def get_capabilities(self, model: Any) -> ModelCapabilities:
+        """Return capabilities for an AWQ-quantized model."""
+        config = getattr(model, "config", None)
+        group_size = 128  # Default AWQ group size
+        if config is not None:
+            quant_cfg = getattr(config, "quantization_config", None)
+            if isinstance(quant_cfg, dict):
+                group_size = quant_cfg.get("group_size", 128)
+            elif quant_cfg is not None:
+                group_size = getattr(quant_cfg, "group_size", 128)
+        return ModelCapabilities.for_awq(group_size=group_size)
 
     def can_handle(self, model: Any) -> bool:
         cfg = getattr(model, "config", None)

invarlock/plugins/hf_bnb_adapter.py

@@ -5,18 +5,73 @@ HuggingFace BitsAndBytes Adapter (plugin)
 Optional adapter for loading 4/8-bit quantized causal LMs via bitsandbytes
 through Transformers. Requires GPU for practical use.
 Install with the `gpu` extra on supported platforms.
+
+This adapter handles both:
+1. Fresh quantization of FP16 models (load_in_8bit/load_in_4bit)
+2. Loading pre-quantized BNB checkpoints (auto-detected via quantization_config)
 """
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import Any
 
+from invarlock.adapters.capabilities import (
+    ModelCapabilities,
+    QuantizationMethod,
+    detect_quantization_from_config,
+)
 from invarlock.adapters.hf_mixin import HFAdapterMixin
 from invarlock.core.api import ModelAdapter
 from invarlock.core.error_utils import wrap_errors
 from invarlock.core.exceptions import DependencyError, ModelLoadError
 
 
+def _is_local_path(model_id: str) -> bool:
+    """Check if model_id is a local filesystem path."""
+    return Path(model_id).exists()
+
+
+def _detect_pre_quantized_bnb(model_id: str) -> tuple[bool, int]:
+    """
+    Detect if a local checkpoint is pre-quantized with BNB.
+
+    Returns:
+        Tuple of (is_pre_quantized, bits) where bits is 8 or 4.
+    """
+    if not _is_local_path(model_id):
+        return False, 0
+
+    config_path = Path(model_id) / "config.json"
+    if not config_path.exists():
+        return False, 0
+
+    try:
+        import json
+
+        config_data = json.loads(config_path.read_text())
+        quant_cfg = config_data.get("quantization_config", {})
+
+        if not quant_cfg:
+            return False, 0
+
+        # Check for BNB quantization
+        quant_method = quant_cfg.get("quant_method", "").lower()
+        if quant_method == "bitsandbytes" or "load_in_8bit" in quant_cfg:
+            if quant_cfg.get("load_in_8bit"):
+                return True, 8
+            if quant_cfg.get("load_in_4bit"):
+                return True, 4
+            # Fallback to bits field
+            bits = quant_cfg.get("bits", 8)
+            return True, bits
+
+    except Exception:
+        pass
+
+    return False, 0
+
+
 class HF_BNB_Adapter(HFAdapterMixin, ModelAdapter):
     name = "hf_bnb"
 
@@ -29,32 +84,72 @@ class HF_BNB_Adapter(HFAdapterMixin, ModelAdapter):
         ):
             from transformers import AutoModelForCausalLM
 
-        # Default to 8-bit if not specified
-        load_in_8bit = bool(kwargs.pop("load_in_8bit", True))
-        load_in_4bit = bool(kwargs.pop("load_in_4bit", False))
+        # Check if this is a pre-quantized checkpoint
+        is_pre_quantized, pre_quant_bits = _detect_pre_quantized_bnb(model_id)
 
-        if load_in_4bit:
-            load_in_8bit = False
+        if is_pre_quantized:
+            # Load pre-quantized checkpoint WITHOUT re-applying quantization
+            with wrap_errors(
+                ModelLoadError,
+                "E201",
+                "MODEL-LOAD-FAILED: bitsandbytes/transformers (pre-quantized)",
+                lambda e: {"model_id": model_id, "pre_quantized_bits": pre_quant_bits},
+            ):
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_id,
+                    device_map="auto",
+                    trust_remote_code=True,
+                    # Do NOT pass load_in_8bit/load_in_4bit for pre-quantized
+                    **{
+                        k: v
+                        for k, v in kwargs.items()
+                        if k not in ("load_in_8bit", "load_in_4bit")
+                    },
+                )
+        else:
+            # Fresh quantization of FP16 model
+            load_in_8bit = bool(kwargs.pop("load_in_8bit", True))
+            load_in_4bit = bool(kwargs.pop("load_in_4bit", False))
 
-        with wrap_errors(
-            ModelLoadError,
-            "E201",
-            "MODEL-LOAD-FAILED: bitsandbytes/transformers",
-            lambda e: {"model_id": model_id},
-        ):
-            model = AutoModelForCausalLM.from_pretrained(
-                model_id,
-                device_map="auto",
-                load_in_8bit=load_in_8bit,
-                load_in_4bit=load_in_4bit,
-                trust_remote_code=True,
-                **kwargs,
-            )
-
-        # Let HF device map place on CUDA if available; ensure device object resolves
-        _ = self._resolve_device(device)
+            if load_in_4bit:
+                load_in_8bit = False
+
+            with wrap_errors(
+                ModelLoadError,
+                "E201",
+                "MODEL-LOAD-FAILED: bitsandbytes/transformers",
+                lambda e: {"model_id": model_id},
+            ):
+                model = AutoModelForCausalLM.from_pretrained(
+                    model_id,
+                    device_map="auto",
+                    load_in_8bit=load_in_8bit,
+                    load_in_4bit=load_in_4bit,
+                    trust_remote_code=True,
+                    **kwargs,
+                )
+
+        # BNB models handle their own device placement via device_map="auto"
+        # Do NOT call .to() on BNB models - it will raise an error
+        _ = self._resolve_device(device)  # Validate device string only
         return model
 
+    def get_capabilities(self, model: Any) -> ModelCapabilities:
+        """Return capabilities for a BNB-quantized model."""
+        config = getattr(model, "config", None)
+        if config is not None:
+            quant_cfg = detect_quantization_from_config(config)
+            if quant_cfg.method == QuantizationMethod.BNB_8BIT:
+                return ModelCapabilities.for_bnb_8bit(from_checkpoint=True)
+            elif quant_cfg.method == QuantizationMethod.BNB_4BIT:
+                return ModelCapabilities.for_bnb_4bit(
+                    from_checkpoint=True,
+                    double_quant=quant_cfg.double_quant,
+                )
+
+        # Default to 8-bit if we can't determine
+        return ModelCapabilities.for_bnb_8bit()
+
     def can_handle(self, model: Any) -> bool:
         cfg = getattr(model, "config", None)
         return hasattr(cfg, "n_layer") or hasattr(cfg, "num_hidden_layers")

invarlock/plugins/hf_gptq_adapter.py

@@ -4,12 +4,16 @@ HuggingFace GPTQ Adapter (plugin)
 
 Optional adapter for loading AutoGPTQ-quantized causal LMs from the Hub.
 Requires the `auto-gptq` extra on supported platforms (typically Linux/CUDA).
+
+GPTQ models are pre-quantized and typically handle device placement internally
+during loading. This adapter uses safe device movement to respect constraints.
 """
 
 from __future__ import annotations
 
 from typing import Any
 
+from invarlock.adapters.capabilities import ModelCapabilities
 from invarlock.adapters.hf_mixin import HFAdapterMixin
 from invarlock.core.api import ModelAdapter
 from invarlock.core.error_utils import wrap_errors
@@ -47,7 +51,26 @@ class HF_GPTQ_Adapter(HFAdapterMixin, ModelAdapter):
                 **{k: v for k, v in kwargs.items() if k not in {"device"}},
             )
 
-        return model.to(self._resolve_device(device))
+        # GPTQ models are pre-quantized; use safe device movement
+        # which respects the model's device constraints
+        return self._safe_to_device(
+            model, device, capabilities=ModelCapabilities.for_gptq()
+        )
+
+    def get_capabilities(self, model: Any) -> ModelCapabilities:
+        """Return capabilities for a GPTQ-quantized model."""
+        config = getattr(model, "config", None)
+        bits = 4  # Default GPTQ bits
+        group_size = 128  # Default GPTQ group size
+        if config is not None:
+            quant_cfg = getattr(config, "quantization_config", None)
+            if isinstance(quant_cfg, dict):
+                bits = quant_cfg.get("bits", 4)
+                group_size = quant_cfg.get("group_size", 128)
+            elif quant_cfg is not None:
+                bits = getattr(quant_cfg, "bits", 4)
+                group_size = getattr(quant_cfg, "group_size", 128)
+        return ModelCapabilities.for_gptq(bits=bits, group_size=group_size)
 
     # ---- Introspection ----
     def can_handle(self, model: Any) -> bool:

{invarlock-0.2.0.dist-info → invarlock-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invarlock
-Version: 0.2.0
+Version: 0.3.0
 Summary: Edit‑agnostic robustness certificates for weight edits (InvarLock framework)
 Author-email: InvarLock Team <oss@invarlock.dev>
 Maintainer-email: InvarLock Maintainers <support@invarlock.dev>
@@ -112,7 +112,7 @@ they don’t, roll back safely.
 Technical: edit‑agnostic guard pipeline (invariants → spectral → RMT →
 variance) producing a machine‑readable Safety Certificate.
 
-> **Status:** 0.2.0 (pre‑1.0). Until 1.0, **minor** releases may be
+> **Status:** 0.3.0 (pre‑1.0). Until 1.0, **minor** releases may be
 > breaking. See CLI help and the CHANGELOG for updates.
 
 [![CI](https://img.shields.io/github/actions/workflow/status/invarlock/invarlock/ci.yml?branch=main&logo=github&label=CI)](https://github.com/invarlock/invarlock/actions/workflows/ci.yml)

{invarlock-0.2.0.dist-info → invarlock-0.3.0.dist-info}/RECORD

@@ -1,4 +1,4 @@
-invarlock/__init__.py,sha256=0wBGSMHtJjmLpssdA6ikmkPj1eMH_3x2q8214sYOguI,1268
+invarlock/__init__.py,sha256=Oan5J3YATdRnh-9M-k6dQh6JAExLsg5SrU2gfoau9dE,1268
 invarlock/__main__.py,sha256=ffhoKctw89j-henmQXThbHDIdlvK9fBfsy8LpjhOEXc,146
 invarlock/config.py,sha256=7BUOl7EW258YnsgRipjOx6lmWou5jNDzimREd35ewsQ,1725
 invarlock/model_profile.py,sha256=sFHpK-1Q-1DjiZTWMolQBG4Dw9feLJgk3GnaD3ixgd8,12809
@@ -9,15 +9,16 @@ invarlock/sparsity_utils.py,sha256=30SC3osptca2GmzxezbfX31EE6sRUhmEz8u3jn4vB2c,8
 invarlock/_data/runtime/tiers.yaml,sha256=A0NMcz5o-TXJp1gZq2Sd7uYAQSsMQcG0ZV1FuLxl5jA,1700
 invarlock/_data/runtime/profiles/ci_cpu.yaml,sha256=N_ur2CkyL_g9-jwTwATniMhdrv0SL64lnHCQvjq-WWQ,324
 invarlock/_data/runtime/profiles/release.yaml,sha256=xF0Qb0OTm904U6L3wK674JMTcDPegYvpKgwUB9pfq_w,482
-invarlock/adapters/__init__.py,sha256=4-q5QEQojX3G57BoJiBWzcFv-Ec9_upWtdxqxNVcJhk,3071
+invarlock/adapters/__init__.py,sha256=Bwj8aKjhFxCzvcdxTIl-nG7IXyIE4L3Nd_fsIghbZxA,3418
 invarlock/adapters/_capabilities.py,sha256=FmzUR5BHsxWe92Z9W1As-G5_5wG1PvqF2sUpjZ2_CdY,1483
-invarlock/adapters/auto.py,sha256=s_rx29AkFen6-1eXMith8o7RN9pSW1b_J21yynhUl8Y,3706
+invarlock/adapters/auto.py,sha256=XWENU5hi66AtMPlQDRuINk1SGW1Kym8Tot-2jXGFGcQ,7643
 invarlock/adapters/base.py,sha256=szSh1bECeDSDGQSr5oIWhs5RlI587gE4gzdt5cnOJ1s,16100
 invarlock/adapters/base_types.py,sha256=3IuHt63_RjGZqoTOdkMpfGPiZTGqcvXXDq1KU-8QemQ,1612
+invarlock/adapters/capabilities.py,sha256=oAK_zgCzAFmss8qAU2zgc8kcahtadGtbPTYR7StXiCo,15360
 invarlock/adapters/hf_bert.py,sha256=DkUXCile7ALlHVZvMkNLAl_YrhHpdmQmomzNyIAPBEo,35547
 invarlock/adapters/hf_gpt2.py,sha256=zuNapMDj4kdzlpGJY11tMOr9dh0V1C0qkOTRwi1xCnQ,14814
-invarlock/adapters/hf_llama.py,sha256=6hDQx62pg_T-7sbVj8xWgJa60030AC9g2TaGLbgG96Q,19069
-invarlock/adapters/hf_mixin.py,sha256=uqprV8XXyhZemWZBnqpyVgDibsS5vTwAYXv6iUPo-HU,14248
+invarlock/adapters/hf_llama.py,sha256=TbE9wII1GAQG7gbtiZCZ4S92rKoWRM7VH5vCnqEHc-4,19102
+invarlock/adapters/hf_mixin.py,sha256=rhm0MbjzoHtEAl54tmW3T7tf1C_VxTtcPSdQ7mQ0CIU,18279
 invarlock/adapters/hf_onnx.py,sha256=kEqgQEEdGUeaXDF0EgaMHOQQMhc1xIvur0bQvdky-AY,4446
 invarlock/adapters/hf_t5.py,sha256=2SpDKPyERrrkTWXcDJDo0J5NNjFLePuC965e1zy2tus,4738
 invarlock/adapters/py.typed,sha256=LCPmZeE_vANVVJDNvuq9A07i7jg9Nxrq6f10UeuNfZc,37
@@ -55,7 +56,7 @@ invarlock/core/contracts.py,sha256=9j55WVwMrEsUqxWlzAdMsHtkzgfkSftdizhcLiJBauw,2
 invarlock/core/error_utils.py,sha256=T23-p5ONQ-SeVuMR4Ts0cWyupsSa-0DAgsejRTfxeCg,1782
 invarlock/core/events.py,sha256=8XBAi-9A7ys7QJQwqlz8PVlfxF0TM_TvLqjcPtDwZm4,9428
 invarlock/core/exceptions.py,sha256=b4OszJ0Fd0Ezy8s99AzprS7lAkqdZYGXaSj9fYaln4E,2077
-invarlock/core/registry.py,sha256=2bpz37u2Tf78N4h78cvTJ0iWrb5VG90CCg3CMzwyUbc,17879
+invarlock/core/registry.py,sha256=vgKmhekteJS2oRu8g3tBHm48z_Eda5oPKq2ajQnDDc4,18884
 invarlock/core/retry.py,sha256=KTVkrTnWs60jwATOZDHinERH56GnOGjsKR0lmohagEo,4503
 invarlock/core/runner.py,sha256=IWp6cL21IzP_7k26AqcCFHg772f3XHO_PK2PB_-DS0s,81448
 invarlock/core/types.py,sha256=nVLMP4yqlxwhE1moQU7FWVeGJqTuud-cvTZiutdBGKk,3585
@@ -89,7 +90,7 @@ invarlock/guards/py.typed,sha256=LCPmZeE_vANVVJDNvuq9A07i7jg9Nxrq6f10UeuNfZc,37
 invarlock/guards/rmt.py,sha256=f_fZEKZyp_xJcmc7wAMNSrzs702JCztfq3zcK4CSJgk,78710
 invarlock/guards/spectral.py,sha256=tOHBoAm23xkPKUYLdr41ZQYHc806pxrhVXwsmoDLiKE,51132
 invarlock/guards/tier_config.py,sha256=_WJIQ4qvIOc8EI1ygBhpBqbZPt072RT6H6Oh9-LqNWY,10706
-invarlock/guards/variance.py,sha256=jB2UTB7fveudF7tRhkrbAXoO774_BWb59Cq2MMCvJ8s,131832
+invarlock/guards/variance.py,sha256=LziyAF5QewT-dtCbRJGb7IklVTIp1IfwTqZhE3yJtv4,133080
 invarlock/guards_ref/__init__.py,sha256=jLnyFqdqQaheG1qQMlU4Gx7R118rkkQHPqFVF3_1ih0,366
 invarlock/guards_ref/rmt_ref.py,sha256=md-aSzLCxPL3OXmrA5NtI9wK7cVSyd2xw8WtSodcGQY,1246
 invarlock/guards_ref/spectral_ref.py,sha256=FdwFfrs5hxEEUIfBV3CvAJvTX78gAM00mKLEXyZ0zJo,4386
@@ -104,9 +105,9 @@ invarlock/observability/py.typed,sha256=LCPmZeE_vANVVJDNvuq9A07i7jg9Nxrq6f10UeuN
 invarlock/observability/utils.py,sha256=1AC3ZEzbrDzTOvSIFxAtWlITy1BHEPZ032HKKzqK_10,16492
 invarlock/plugins/__init__.py,sha256=aZqkpuTT0K3y0SX4702k3YpHnM3kng9fz0qO3XE43hY,260
 invarlock/plugins/hello_guard.py,sha256=-peYJaZd52bbdw6y8cBxEd3CbtFWualDs8nX60CeXhI,896
-invarlock/plugins/hf_awq_adapter.py,sha256=oKo9oP5WelHC5kymKhpqv1ORdMuXfp9TgxXUNbeegx0,2772
-invarlock/plugins/hf_bnb_adapter.py,sha256=kH_jDTqIjk5uzdRI19GeOvDQif1KxQHuv3Ac8ZDbo8A,2548
-invarlock/plugins/hf_gptq_adapter.py,sha256=A9AY0SkDifZL4dAJlCtqwUieVOgKp-1sl4gghvVjNTI,2582
+invarlock/plugins/hf_awq_adapter.py,sha256=UGwzcqJyuqrYHWZ4F-vn-9LNfEDyolOgVDBi0jN35xc,3770
+invarlock/plugins/hf_bnb_adapter.py,sha256=g0ysWEi8dQzLtJy8iCszfTsYCOACuZMFYnTLMAEVxs0,6011
+invarlock/plugins/hf_gptq_adapter.py,sha256=ysugAcnjLqF5sqpijSNiim1xUpRmoIgBrG053X3S2hE,3743
 invarlock/plugins/py.typed,sha256=LCPmZeE_vANVVJDNvuq9A07i7jg9Nxrq6f10UeuNfZc,37
 invarlock/reporting/__init__.py,sha256=A0541EqxcdTpslNbZEWIO4q-LCqzCQcadev2IBKEBbM,232
 invarlock/reporting/certificate.py,sha256=3xlAryynUh31iGenN7us3L3VGYB8vW722uVYGQiXdrM,124085
@@ -124,9 +125,9 @@ invarlock/reporting/utils.py,sha256=1aLYgSUR4XvgmhDvU9YK9ICd7W5sjft1qdsZC9JJSRY,
 invarlock/reporting/validate.py,sha256=396Fe4SPII4zaD1adGtH2hsl5asQOCDqDL4W3YixEXU,22453
 invarlock/utils/__init__.py,sha256=DR2pBrgddLH2PW-6ninOE8CM7DNvlvgyYsCkckozbPU,4276
 invarlock/utils/digest.py,sha256=sfnqGFRiRf7l950MjSIrWO1XbUfXlcEfNLeWFbBUr8I,1290
-invarlock-0.2.0.dist-info/licenses/LICENSE,sha256=uFddaXYY02nEFdPpS7bam_bnm0st41BibzD0jHULPXw,10413
-invarlock-0.2.0.dist-info/METADATA,sha256=C0bQOmPMu9IwbiHk6tyHn2sPhO3Fld-bKfc8NCgS5KU,21783
-invarlock-0.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-invarlock-0.2.0.dist-info/entry_points.txt,sha256=i0e4ZzmJNMBGG-69lbgP-muEcn1je2TUIWwl9SJERm0,670
-invarlock-0.2.0.dist-info/top_level.txt,sha256=GXfftc_YDHHcQC2vQgYbZ5cTO82YuWY3HusHMT3DuKs,10
-invarlock-0.2.0.dist-info/RECORD,,
+invarlock-0.3.0.dist-info/licenses/LICENSE,sha256=uFddaXYY02nEFdPpS7bam_bnm0st41BibzD0jHULPXw,10413
+invarlock-0.3.0.dist-info/METADATA,sha256=MtsIbRufSXZ3xxDzNbxjDrYH0oDhIb1xDQdlElAsdjw,21783
+invarlock-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+invarlock-0.3.0.dist-info/entry_points.txt,sha256=i0e4ZzmJNMBGG-69lbgP-muEcn1je2TUIWwl9SJERm0,670
+invarlock-0.3.0.dist-info/top_level.txt,sha256=GXfftc_YDHHcQC2vQgYbZ5cTO82YuWY3HusHMT3DuKs,10
+invarlock-0.3.0.dist-info/RECORD,,