koios-model-utils 1.0.0rc1__py3-none-any.whl

koios_model_utils/__init__.py

@@ -0,0 +1,47 @@
+"""koios-model-utils — utilities for exporting and annotating ONNX models for the Koios IoT platform."""
+
+__version__ = "1.0.0rc1"
+
+from koios_model_utils.metadata import (
+    InputBinding,
+    OutputBinding,
+    TrainingMeta,
+    build_input_bindings,
+    build_output_bindings,
+    embed_koios_metadata,
+)
+
+# SB3-dependent exports — only available with koios-model-utils[sb3]
+try:
+    from koios_model_utils.callbacks import (
+        ObsRangeCallback,
+        VecNormalizeSyncCallback,
+    )
+    from koios_model_utils.export import (
+        OnnxActorWrapper,
+        OnnxDQNWrapper,
+        detect_algorithm,
+        export_onnx,
+        load_vec_normalize_stats,
+    )
+except ImportError:
+    pass
+
+__all__ = [
+    # metadata (always available)
+    "InputBinding",
+    "OutputBinding",
+    "TrainingMeta",
+    "embed_koios_metadata",
+    "build_input_bindings",
+    "build_output_bindings",
+    # export (requires sb3 extra)
+    "export_onnx",
+    "detect_algorithm",
+    "load_vec_normalize_stats",
+    "OnnxActorWrapper",
+    "OnnxDQNWrapper",
+    # callbacks (requires sb3 extra)
+    "ObsRangeCallback",
+    "VecNormalizeSyncCallback",
+]

koios_model_utils/callbacks.py

@@ -0,0 +1,147 @@
+"""SB3 training callbacks for Koios model export."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import numpy as np
+from stable_baselines3.common.callbacks import BaseCallback
+
+if TYPE_CHECKING:
+    from stable_baselines3.common.callbacks import EvalCallback
+
+
+class ObsRangeCallback(BaseCallback):
+    """Track per-feature min/max of raw (pre-normalization) observations.
+
+    Saves ``obs_range.json`` to the run directory on training end, containing
+    the observed min/max per feature across all training steps.  These are used
+    as failure bounds in Koios — if a live value falls outside the range the
+    model was trained on, the binding is flagged as untrusted.
+
+    Works with both raw envs and VecNormalize-wrapped envs.  When VecNormalize
+    is present, the original (un-normalized) observations are tracked.
+    """
+
+    def __init__(self, run_dir: str | Path, verbose: int = 0) -> None:
+        super().__init__(verbose)
+        self._run_dir = Path(run_dir)
+        self._obs_min: np.ndarray | None = None
+        self._obs_max: np.ndarray | None = None
+
+    def _on_step(self) -> bool:
+        # Get raw observations — use original obs when normalization is active
+        obs = None
+
+        # Path 1: VecNormalize (z_score)
+        vec_norm = self.model._vec_normalize_env  # type: ignore[union-attr]
+        if vec_norm is not None:
+            obs = vec_norm.get_original_obs()
+
+        # Path 2: MinMaxObsWrapper — walk wrapper chain for _last_original_obs
+        if obs is None:
+            env = self.training_env
+            # Unwrap through VecEnv layers to find the underlying env
+            while hasattr(env, "envs"):
+                env = env.envs[0]  # type: ignore[union-attr]
+            # Walk Gymnasium wrapper chain
+            current = env
+            while current is not None:
+                if hasattr(current, "_last_original_obs"):
+                    obs = current._last_original_obs
+                    break
+                current = getattr(current, "env", None)
+
+        # Path 3: fallback to raw obs
+        if obs is None:
+            obs = self.locals.get("new_obs")
+
+        if obs is None:
+            return True
+
+        obs = np.asarray(obs, dtype=np.float32)
+
+        # Flatten to (n_envs, num_features) — collapse obs_depth if present
+        if obs.ndim == 3:
+            # (n_envs, obs_depth, num_features) → min/max across envs and depth
+            flat = obs.reshape(-1, obs.shape[-1])
+        elif obs.ndim == 2:
+            flat = obs
+        else:
+            flat = obs.reshape(1, -1)
+
+        step_min = flat.min(axis=0)
+        step_max = flat.max(axis=0)
+
+        if self._obs_min is None:
+            self._obs_min = step_min.copy()
+            self._obs_max = step_max.copy()
+        else:
+            np.minimum(self._obs_min, step_min, out=self._obs_min)
+            np.maximum(self._obs_max, step_max, out=self._obs_max)
+
+        return True
+
+    def _on_training_end(self) -> None:
+        if self._obs_min is None or self._obs_max is None:
+            return
+
+        out_path = self._run_dir / "obs_range.json"
+        data = {
+            "obs_min": self._obs_min.tolist(),
+            "obs_max": self._obs_max.tolist(),
+        }
+        with open(out_path, "w") as f:
+            json.dump(data, f, indent=2)
+
+        if self.verbose >= 1:
+            print(f"Observation ranges saved to {out_path}")
+            for i, (lo, hi) in enumerate(zip(self._obs_min, self._obs_max)):
+                print(f"  feature {i}: [{lo:.4f}, {hi:.4f}]")
+
+
+class VecNormalizeSyncCallback(BaseCallback):
+    """Save VecNormalize stats alongside every new best model.
+
+    SB3's ``EvalCallback`` saves ``best_model.zip`` when eval reward improves,
+    but doesn't save the VecNormalize running statistics.  Without the stats
+    file, an early ``koios-export`` on ``best_model.zip`` produces an ONNX with
+    no z-score metadata — the PE then feeds raw observations to a model that
+    expects normalized ones.
+
+    This callback checks after each eval whether a new best model was saved
+    and, if so, writes ``vec_normalize.pkl`` to the same directory.
+    """
+
+    def __init__(self, eval_callback: EvalCallback, verbose: int = 0) -> None:
+        super().__init__(verbose)
+        self._eval_cb = eval_callback
+        self._last_best_timestep: int = -1
+
+    def _on_step(self) -> bool:
+        # EvalCallback sets best_mean_reward and n_calls when a new best is saved
+        best_ts = getattr(self._eval_cb, "best_mean_reward_timestep", None)
+        if best_ts is None:
+            # Fallback: check if best_model.zip was updated by comparing n_calls
+            best_ts = getattr(self._eval_cb, "n_calls", 0)
+
+        # Detect new best model by checking if EvalCallback updated its best
+        vec_norm = self.model._vec_normalize_env  # type: ignore[union-attr]
+        if vec_norm is None:
+            return True
+
+        best_path = Path(self._eval_cb.best_model_save_path) / "best_model.zip"
+        stats_path = Path(self._eval_cb.best_model_save_path) / "vec_normalize.pkl"
+
+        # Save if best_model.zip exists and is newer than our last save
+        if best_path.exists():
+            mtime = best_path.stat().st_mtime_ns
+            if mtime != self._last_best_timestep:
+                self._last_best_timestep = mtime
+                vec_norm.save(str(stats_path))
+                if self.verbose >= 1:
+                    print(f"[VecNormSync] Saved {stats_path}")
+
+        return True

koios_model_utils/export.py

@@ -0,0 +1,662 @@
+"""ONNX export — ``koios-export runs/tank_level_ppo/best_model.zip``."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import pickle
+import sys
+import zipfile
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn as nn
+
+from koios_model_utils.metadata import (
+    InputBinding,
+    OutputBinding,
+    TrainingMeta,
+    build_input_bindings,
+    build_output_bindings,
+    embed_koios_metadata,
+)
+
+# ---------------------------------------------------------------------------
+# Algorithm detection
+# ---------------------------------------------------------------------------
+
+_ALGO_CLASS_PREFIXES = {
+    "stable_baselines3.ppo": "PPO",
+    "stable_baselines3.sac": "SAC",
+    "stable_baselines3.td3": "TD3",
+    "stable_baselines3.a2c": "A2C",
+    "stable_baselines3.dqn": "DQN",
+}
+
+
+def detect_algorithm(model_path: str | Path) -> str:
+    """Detect the SB3 algorithm from a saved .zip model.
+
+    SB3 stores a ``data`` file inside the zip containing pickled metadata
+    that includes the class path.  We read this without unpickling by
+    scanning for the class prefix strings.
+    """
+    model_path = Path(model_path)
+    with zipfile.ZipFile(model_path, "r") as zf:
+        if "data" in zf.namelist():
+            raw = zf.read("data")
+            text = raw.decode("latin-1")  # binary-safe decode for scanning
+            for prefix, algo_name in _ALGO_CLASS_PREFIXES.items():
+                if prefix in text:
+                    return algo_name
+
+    # Fallback: try to infer from the directory or filename
+    name_lower = model_path.stem.lower()
+    for algo in ("sac", "td3", "a2c", "ppo"):
+        if algo in name_lower:
+            return algo.upper()
+
+    return "PPO"  # Default assumption
+
+
+# ---------------------------------------------------------------------------
+# ONNX actor wrappers (require torch — imported lazily)
+# ---------------------------------------------------------------------------
+
+
+class OnnxActorWrapper(nn.Module):
+    """Wraps an SB3 policy's actor-only forward path for ONNX export.
+
+    Extracts the deterministic actor from both on-policy (PPO, A2C) and
+    off-policy (SAC, TD3) architectures:
+
+      - PPO/A2C: features_extractor -> mlp_extractor.policy_net -> action_net -> clamp
+      - SAC:     features_extractor -> actor.latent_pi -> actor.mu -> tanh -> clamp
+      - TD3:     features_extractor -> actor.latent_pi -> actor.mu -> clamp
+
+    SAC uses a SquashedDiagGaussianDistribution — deterministic actions are
+    ``tanh(mu)``, not raw ``mu``.  When *squash_output* is True, ``tanh`` is
+    applied before clamping to match SB3's ``predict(deterministic=True)``.
+
+    Normalization and denormalization are NOT baked in — the Koios predict
+    engine applies them based on embedded ``koios.bindings`` metadata.
+
+    Forward: obs [1, obs_depth, num_features] -> actions [1, num_actions]
+    """
+
+    def __init__(
+        self,
+        policy: nn.Module,
+        action_low: torch.Tensor,
+        action_high: torch.Tensor,
+        *,
+        squash_output: bool = False,
+    ) -> None:
+        super().__init__()
+        self.register_buffer("action_low", action_low)
+        self.register_buffer("action_high", action_high)
+        self.squash_output = squash_output
+
+        # Detect architecture: SAC/TD3 have policy.actor, PPO/A2C have mlp_extractor
+        if hasattr(policy, "actor") and hasattr(policy.actor, "latent_pi"):
+            # SAC / TD3: everything lives on the actor sub-module
+            self.features_extractor = policy.actor.features_extractor
+            self.hidden_net = policy.actor.latent_pi
+            self.output_net = policy.actor.mu
+        else:
+            # PPO / A2C: features_extractor on policy, actor split across mlp_extractor + action_net
+            self.features_extractor = policy.features_extractor
+            self.hidden_net = policy.mlp_extractor.policy_net
+            self.output_net = policy.action_net
+
+    def forward(self, obs: torch.Tensor) -> torch.Tensor:
+        features = self.features_extractor(obs)
+        latent = self.hidden_net(features)
+        actions = self.output_net(latent)
+        if self.squash_output:
+            actions = torch.tanh(actions)
+        actions = torch.clamp(actions, self.action_low, self.action_high)
+        return actions
+
+
+class OnnxDQNWrapper(nn.Module):
+    """Wraps DQN's Q-network for ONNX export.
+
+    Outputs raw Q-values ``[1, num_actions]``.  The Koios predict engine
+    applies ``argmax`` and ``action_map`` lookup.
+
+    Forward: obs ``[1, obs_depth, num_features]`` -> q_values ``[1, num_actions]``
+    """
+
+    def __init__(self, policy: nn.Module) -> None:
+        super().__init__()
+        self.features_extractor = policy.q_net.features_extractor
+        self.q_net = policy.q_net.q_net  # The actual Q-value MLP
+
+    def forward(self, obs: torch.Tensor) -> torch.Tensor:
+        features = self.features_extractor(obs)
+        return self.q_net(features)
+
+
+# ---------------------------------------------------------------------------
+# VecNormalize stats loader
+# ---------------------------------------------------------------------------
+
+
+def load_vec_normalize_stats(
+    stats_path: str | Path,
+) -> tuple[np.ndarray, np.ndarray, float] | None:
+    """Load observation mean/var from a saved VecNormalize pickle.
+
+    Returns (mean, var, clip_obs) or None if loading fails.
+    """
+    try:
+        with open(stats_path, "rb") as f:
+            vec_normalize = pickle.load(f)
+        mean = np.array(vec_normalize.obs_rms.mean, dtype=np.float32)
+        var = np.array(vec_normalize.obs_rms.var, dtype=np.float32)
+        clip_obs = float(getattr(vec_normalize, "clip_obs", 10.0))
+        return mean, var, clip_obs
+    except Exception as exc:
+        print(f"WARNING: Could not load VecNormalize stats from {stats_path}: {exc}")
+        return None
+
+
+# ---------------------------------------------------------------------------
+# Export function
+# ---------------------------------------------------------------------------
+
+
+def export_onnx(
+    model_path: str | Path,
+    output_path: str | Path | None = None,
+    *,
+    inputs: list[InputBinding] | None = None,
+    outputs: list[OutputBinding] | None = None,
+    training: TrainingMeta | None = None,
+    opset_version: int = 18,
+    verify: bool = True,
+    num_verify_samples: int = 100,
+) -> Path:
+    """Export an SB3 model to ONNX for the Koios predict engine.
+
+    The exported ONNX contains only the raw actor network — no observation
+    normalization or output denormalization is baked in.  Instead, those
+    parameters are embedded in ``koios.bindings`` metadata so the predict
+    engine can apply them per-binding:
+
+    - **Inputs**: Z-Score normalization from VecNormalize running stats.
+    - **Outputs**: Symmetric denormalization from [-1, 1] to action ranges.
+
+    Parameters
+    ----------
+    model_path:
+        Path to an SB3 ``.zip`` model file.
+    output_path:
+        Destination ``.onnx`` file.  Defaults to the same directory and stem
+        as *model_path* with ``.onnx`` extension.
+    inputs:
+        Optional input bindings for Koios metadata embedding.
+    outputs:
+        Optional output bindings for Koios metadata embedding.
+    training:
+        Optional training metadata for Koios metadata embedding.
+    opset_version:
+        ONNX opset version (default 18).
+    verify:
+        If True, validate the exported ONNX and compare outputs with SB3.
+    num_verify_samples:
+        Number of random observations to compare during verification.
+
+    Returns
+    -------
+    Path to the exported ``.onnx`` file.
+    """
+    import onnx
+    import stable_baselines3 as sb3
+
+    model_path = Path(model_path)
+    if output_path is None:
+        output_path = model_path.with_suffix(".onnx")
+    else:
+        output_path = Path(output_path)
+
+    # ------------------------------------------------------------------
+    # 1. Load SB3 model
+    # ------------------------------------------------------------------
+    algo_name = detect_algorithm(model_path)
+    algo_map = {"PPO": sb3.PPO, "SAC": sb3.SAC, "TD3": sb3.TD3, "A2C": sb3.A2C, "DQN": sb3.DQN}
+    algo_cls = algo_map[algo_name]
+    model = algo_cls.load(str(model_path), device="cpu")
+    print(f"Loaded {algo_name} model from {model_path}")
+
+    policy = model.policy
+    policy.eval()
+
+    obs_space = model.observation_space
+    act_space = model.action_space
+    is_dqn = algo_name == "DQN"
+
+    # ------------------------------------------------------------------
+    # 2. Load observation normalization stats (if VecNormalize was used)
+    # ------------------------------------------------------------------
+    obs_stats_np: tuple[np.ndarray, np.ndarray, float, float] | None = None
+    obs_clip: float = 10.0
+    obs_epsilon: float = 1e-8
+
+    stats_path = model_path.parent / "vec_normalize.pkl"
+    if stats_path.exists():
+        stats = load_vec_normalize_stats(stats_path)
+        if stats is not None:
+            mean_np, var_np, obs_clip = stats
+            obs_stats_np = (mean_np, var_np, obs_clip, obs_epsilon)
+            print(f"Loaded VecNormalize stats from {stats_path} (will embed in metadata)")
+            print(f"  obs shape: {mean_np.shape}, clip: {obs_clip}")
+
+    # ------------------------------------------------------------------
+    # 3. Create ONNX wrapper (raw actor — no baked normalization)
+    # ------------------------------------------------------------------
+    if is_dqn:
+        wrapper = OnnxDQNWrapper(policy)
+        output_names = ["q_values"]
+    else:
+        action_low = torch.tensor(act_space.low, dtype=torch.float32)
+        action_high = torch.tensor(act_space.high, dtype=torch.float32)
+
+        squash = algo_name == "SAC"
+
+        wrapper = OnnxActorWrapper(
+            policy,
+            action_low,
+            action_high,
+            squash_output=squash,
+        )
+        output_names = ["actions"]
+    wrapper.eval()
+
+    # ------------------------------------------------------------------
+    # 4. Build dummy input with static shape [1, obs_depth, num_features]
+    # ------------------------------------------------------------------
+    obs_shape = obs_space.shape
+    dummy_input = torch.randn(1, *obs_shape, dtype=torch.float32)
+
+    # ------------------------------------------------------------------
+    # 5. Export to ONNX
+    # ------------------------------------------------------------------
+    torch.onnx.export(
+        wrapper,
+        (dummy_input,),
+        str(output_path),
+        opset_version=opset_version,
+        input_names=["observations"],
+        output_names=output_names,
+        dynamic_axes=None,
+    )
+    print(f"Exported ONNX model to {output_path}")
+
+    # ------------------------------------------------------------------
+    # 5b. Consolidate external data into single file
+    # ------------------------------------------------------------------
+    data_path = output_path.parent / (output_path.name + ".data")
+    if data_path.exists():
+        onnx_model = onnx.load(str(output_path), load_external_data=True)
+        for init in onnx_model.graph.initializer:
+            if init.data_location == onnx.TensorProto.EXTERNAL:
+                init.data_location = onnx.TensorProto.DEFAULT
+        onnx.save_model(onnx_model, str(output_path))
+        data_path.unlink()
+        print("Consolidated external data into single .onnx file")
+
+    # ------------------------------------------------------------------
+    # 6. Validate with onnx checker
+    # ------------------------------------------------------------------
+    onnx_model = onnx.load(str(output_path))
+    onnx.checker.check_model(onnx_model)
+    print("ONNX model passes onnx.checker validation")
+
+    # ------------------------------------------------------------------
+    # 6b. Embed Koios training metadata
+    # ------------------------------------------------------------------
+    if inputs is not None and outputs is not None:
+        embed_koios_metadata(
+            onnx_model,
+            inputs=inputs,
+            outputs=outputs,
+            training=training,
+        )
+        onnx.save_model(onnx_model, str(output_path))
+
+    # ------------------------------------------------------------------
+    # 7. Verify outputs match SB3
+    # ------------------------------------------------------------------
+    if verify:
+        if is_dqn:
+            _verify_dqn_outputs(policy, wrapper, obs_space, num_verify_samples)
+        else:
+            _verify_outputs(
+                model,
+                wrapper,
+                obs_space,
+                num_verify_samples,
+                obs_mean_np=obs_stats_np[0] if obs_stats_np else None,
+                obs_var_np=obs_stats_np[1] if obs_stats_np else None,
+                obs_clip=obs_clip,
+                obs_epsilon=obs_epsilon,
+            )
+
+    # ------------------------------------------------------------------
+    # 8. Print summary
+    # ------------------------------------------------------------------
+    input_shape = [d.dim_value for d in onnx_model.graph.input[0].type.tensor_type.shape.dim]
+    output_shape = [d.dim_value for d in onnx_model.graph.output[0].type.tensor_type.shape.dim]
+
+    print(f"\n{'=' * 50}")
+    print("ONNX Export Summary")
+    print(f"{'=' * 50}")
+    print(f"Algorithm:    {algo_name}")
+    print("Input name:   observations")
+    print(f"Input shape:  {input_shape}")
+    print(f"Output name:  {output_names[0]}")
+    print(f"Output shape: {output_shape}")
+    print(f"Opset:        {opset_version}")
+    if obs_stats_np is not None:
+        print("Obs normalization: Z-Score (Koios-applied)")
+    elif inputs is not None and any(b.normalization_type == "min_max" for b in inputs):
+        print("Obs normalization: Min/Max (Koios-applied)")
+    else:
+        print("Obs normalization: none")
+    if inputs is not None:
+        print("Output denorm:     Symmetric (Koios-applied)")
+
+    if input_shape and len(input_shape) == 3:
+        print("\nPredict Engine mapping:")
+        print(f"  depth_samples = {input_shape[1]}")
+        print(f"  num_features  = {input_shape[2]}")
+        print(f"  num_outputs   = {output_shape[1] if len(output_shape) > 1 else 1}")
+
+    if outputs is not None:
+        print("\nAction node mapping:")
+        for i, out in enumerate(outputs):
+            print(f"  binding_order={i + 1} -> {out.name}")
+
+    print(f"{'=' * 50}")
+    return output_path
+
+
+# ---------------------------------------------------------------------------
+# Verification helpers
+# ---------------------------------------------------------------------------
+
+
+def _verify_outputs(
+    sb3_model: object,
+    wrapper: object,
+    obs_space: object,
+    num_samples: int,
+    obs_mean_np: np.ndarray | None = None,
+    obs_var_np: np.ndarray | None = None,
+    obs_clip: float = 10.0,
+    obs_epsilon: float = 1e-8,
+) -> None:
+    """Compare SB3 predict() with ONNX wrapper on random observations."""
+    max_action_diff = 0.0
+    rng = np.random.default_rng(42)
+
+    low = np.where(np.isfinite(obs_space.low), obs_space.low, -1.0)  # type: ignore[union-attr]
+    high = np.where(np.isfinite(obs_space.high), obs_space.high, 1.0)  # type: ignore[union-attr]
+
+    for _ in range(num_samples):
+        raw_obs = rng.uniform(low, high).astype(np.float32)
+
+        if obs_mean_np is not None and obs_var_np is not None:
+            norm_obs = (raw_obs - obs_mean_np) / np.sqrt(obs_var_np + obs_epsilon)
+            norm_obs = np.clip(norm_obs, -obs_clip, obs_clip)
+        else:
+            norm_obs = raw_obs
+
+        sb3_action, _ = sb3_model.predict(norm_obs, deterministic=True)  # type: ignore[union-attr]
+
+        obs_tensor = torch.from_numpy(norm_obs).unsqueeze(0)
+        with torch.no_grad():
+            onnx_action = wrapper(obs_tensor).numpy().squeeze(0)
+
+        diff = np.max(np.abs(sb3_action - onnx_action))
+        max_action_diff = max(max_action_diff, diff)
+
+    print(f"Verification: max action diff across {num_samples} samples = {max_action_diff:.2e}")
+    if max_action_diff > 1e-5:
+        print(f"WARNING: max action diff {max_action_diff:.2e} exceeds 1e-5 threshold")
+    else:
+        print("Action verification PASSED (max diff < 1e-5)")
+
+
+def _verify_dqn_outputs(
+    policy: object,
+    wrapper: object,
+    obs_space: object,
+    num_samples: int,
+) -> None:
+    """Compare DQN Q-network outputs with the ONNX wrapper on random observations."""
+    max_diff = 0.0
+    rng = np.random.default_rng(42)
+
+    low = np.where(np.isfinite(obs_space.low), obs_space.low, -1.0)  # type: ignore[union-attr]
+    high = np.where(np.isfinite(obs_space.high), obs_space.high, 1.0)  # type: ignore[union-attr]
+
+    for _ in range(num_samples):
+        raw_obs = rng.uniform(low, high).astype(np.float32)
+        obs_tensor = torch.from_numpy(raw_obs).unsqueeze(0)
+
+        with torch.no_grad():
+            sb3_qvals = policy.q_net(obs_tensor)  # type: ignore[union-attr]
+            onnx_qvals = wrapper(obs_tensor)
+
+        diff = float(torch.max(torch.abs(sb3_qvals - onnx_qvals)).item())
+        max_diff = max(max_diff, diff)
+
+    print(f"Verification: max Q-value diff across {num_samples} samples = {max_diff:.2e}")
+    if max_diff > 1e-5:
+        print(f"WARNING: max Q-value diff {max_diff:.2e} exceeds 1e-5 threshold")
+    else:
+        print("Q-value verification PASSED (max diff < 1e-5)")
+
+
+# ---------------------------------------------------------------------------
+# CLI config bridge
+# ---------------------------------------------------------------------------
+
+
+def _bindings_from_config(
+    config: object,
+    model_path: Path,
+    obs_stats: tuple[np.ndarray, np.ndarray, float, float] | None = None,
+    obs_norm_minmax: tuple[np.ndarray, np.ndarray] | None = None,
+    obs_range: tuple[np.ndarray, np.ndarray] | None = None,
+) -> tuple[list[InputBinding], list[OutputBinding], TrainingMeta]:
+    """Build bindings from a sim_training ExperimentConfig (lazy import).
+
+    This bridges the old --config CLI interface.  It requires
+    koios-scenario-simulator to be installed.
+    """
+    from sim_training.config import ExperimentConfig
+    from sim_training.env import make_env
+
+    assert isinstance(config, ExperimentConfig)
+
+    env = make_env(config)
+    unwrapped = env.unwrapped
+
+    # Build description lookup from scenario
+    probe = unwrapped._scenario_cls(rng=np.random.default_rng(0))
+    node_specs = probe.define_nodes()
+    desc_map = {s.name: s.description for s in node_specs}
+
+    is_discrete = bool(getattr(config, "discrete_actions", None))
+
+    inputs = build_input_bindings(
+        list(unwrapped._obs_nodes),
+        descriptions=desc_map,
+        obs_stats=obs_stats,
+        obs_norm_minmax=obs_norm_minmax,
+        obs_range=obs_range,
+    )
+    outputs = build_output_bindings(
+        list(unwrapped._action_nodes),
+        unwrapped._action_ranges,
+        descriptions=desc_map,
+        discrete=is_discrete,
+    )
+
+    # Detect algorithm from best_model if available
+    algo = config.algorithm
+    best_model = config.run_dir / "best_model.zip"
+    if best_model.exists():
+        algo = detect_algorithm(best_model)
+
+    training = TrainingMeta(
+        scenario_name=config.scenario_name,
+        algorithm=algo,
+        obs_depth=config.obs_depth,
+        sample_rate=config.dt,
+        model_type="POSITIONAL",
+    )
+    if is_discrete:
+        training.output_mode = "DISCRETE"
+        action_map = getattr(config, "action_map", None)
+        if action_map:
+            training.action_map = action_map
+
+    env.close()
+    return inputs, outputs, training
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Export an SB3 model to ONNX for the Koios predict engine."
+    )
+    parser.add_argument(
+        "model",
+        help="Path to saved SB3 model .zip file.",
+    )
+    parser.add_argument(
+        "--output",
+        "-o",
+        help="Output .onnx file path. Defaults to same directory with .onnx extension.",
+    )
+    parser.add_argument(
+        "--config",
+        "-c",
+        help="Path to config YAML for action node metadata.",
+    )
+    parser.add_argument(
+        "--opset",
+        type=int,
+        default=18,
+        help="ONNX opset version (default: 18).",
+    )
+    parser.add_argument(
+        "--no-verify",
+        action="store_true",
+        help="Skip output verification against SB3 predict.",
+    )
+    parser.add_argument(
+        "--verify-samples",
+        type=int,
+        default=100,
+        help="Number of random samples for verification (default: 100).",
+    )
+    args = parser.parse_args()
+
+    model_path = Path(args.model)
+    if not model_path.exists():
+        model_path = model_path.with_suffix(".zip")
+    if not model_path.exists():
+        print(f"Model not found: {args.model}")
+        sys.exit(1)
+
+    # Auto-detect config from model's directory if not specified
+    config_path = args.config
+    if config_path is None:
+        candidate = model_path.parent / "config.yaml"
+        if candidate.exists():
+            config_path = str(candidate)
+
+    # Build bindings from config (requires koios-scenario-simulator)
+    inputs_list: list[InputBinding] | None = None
+    outputs_list: list[OutputBinding] | None = None
+    training_meta: TrainingMeta | None = None
+
+    if config_path:
+        try:
+            from sim_training.config import load_config as _load_config
+
+            config = _load_config(config_path)
+
+            # Load VecNormalize stats (z_score)
+            obs_stats_np: tuple[np.ndarray, np.ndarray, float, float] | None = None
+            stats_file = model_path.parent / "vec_normalize.pkl"
+            if stats_file.exists():
+                stats = load_vec_normalize_stats(stats_file)
+                if stats is not None:
+                    mean_np, var_np, clip = stats
+                    obs_stats_np = (mean_np, var_np, clip, 1e-8)
+
+            # Load min_max normalization bounds
+            obs_norm_minmax_data: tuple[np.ndarray, np.ndarray] | None = None
+            minmax_file = model_path.parent / "minmax_normalize.json"
+            if minmax_file.exists():
+                with open(minmax_file) as f:
+                    minmax_json = json.load(f)
+                obs_norm_minmax_data = (
+                    np.array(minmax_json["obs_mins"], dtype=np.float32),
+                    np.array(minmax_json["obs_maxs"], dtype=np.float32),
+                )
+                print(f"Loaded min_max normalization from {minmax_file}")
+
+            # Load observation ranges (failure bounds)
+            obs_range_data: tuple[np.ndarray, np.ndarray] | None = None
+            obs_range_path = model_path.parent / "obs_range.json"
+            if obs_range_path.exists():
+                with open(obs_range_path) as f:
+                    range_json = json.load(f)
+                obs_range_data = (
+                    np.array(range_json["obs_min"], dtype=np.float32),
+                    np.array(range_json["obs_max"], dtype=np.float32),
+                )
+                print(f"Loaded observation ranges from {obs_range_path}")
+
+            inputs_list, outputs_list, training_meta = _bindings_from_config(
+                config,
+                model_path,
+                obs_stats=obs_stats_np,
+                obs_norm_minmax=obs_norm_minmax_data,
+                obs_range=obs_range_data,
+            )
+        except ImportError:
+            print("WARNING: sim_training not available — skipping metadata embedding.")
+            print("Pass explicit bindings via the Python API instead.")
+
+    try:
+        export_onnx(
+            model_path,
+            output_path=args.output,
+            inputs=inputs_list,
+            outputs=outputs_list,
+            training=training_meta,
+            opset_version=args.opset,
+            verify=not args.no_verify,
+            num_verify_samples=args.verify_samples,
+        )
+    except KeyboardInterrupt:
+        print("\nExport interrupted.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

koios_model_utils/metadata.py

@@ -0,0 +1,299 @@
+"""Koios ONNX metadata embedding — no torch/SB3 dependency."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import UTC, datetime
+
+import numpy as np
+import onnx
+
+# ---------------------------------------------------------------------------
+# Dataclasses
+# ---------------------------------------------------------------------------
+
+
+@dataclass
+class InputBinding:
+    """Describes one input (observation) binding for the Koios predict engine."""
+
+    name: str
+    description: str = ""
+    normalization_type: str = "none"
+    normalization_source: str | None = None
+    custom_mean: float | None = None
+    custom_std: float | None = None
+    custom_minimum: float | None = None  # for min_max normalization
+    custom_maximum: float | None = None  # for min_max normalization
+    custom_failure: bool = False
+    custom_failure_minimum: float | None = None
+    custom_failure_maximum: float | None = None
+
+
+@dataclass
+class OutputBinding:
+    """Describes one output (action) binding for the Koios predict engine."""
+
+    name: str
+    description: str = ""
+    range_min: float | None = None
+    range_max: float | None = None
+    normalization_type: str = "none"
+    normalization_source: str | None = None
+    custom_minimum: float | None = None
+    custom_maximum: float | None = None
+    clamp_output: bool = False
+
+
+@dataclass
+class TrainingMeta:
+    """Model-level training metadata for the Koios predict engine."""
+
+    scenario_name: str = ""
+    algorithm: str = ""
+    obs_depth: int = 1
+    sample_rate: float = 1.0
+    model_type: str = "POSITIONAL"
+    output_mode: str | None = None
+    action_map: list[dict] | None = None
+
+
+# ---------------------------------------------------------------------------
+# Core function
+# ---------------------------------------------------------------------------
+
+
+def embed_koios_metadata(
+    onnx_model: onnx.ModelProto,
+    *,
+    inputs: list[InputBinding],
+    outputs: list[OutputBinding],
+    training: TrainingMeta | None = None,
+) -> None:
+    """Embed ``koios.training`` and ``koios.bindings`` metadata into an ONNX model (in-place).
+
+    Parameters
+    ----------
+    onnx_model:
+        Loaded ONNX model proto (modified in-place).
+    inputs:
+        Input binding definitions (one per observation feature).
+    outputs:
+        Output binding definitions (one per action).
+    training:
+        Optional model-level training metadata.
+    """
+    # koios.training
+    if training is None:
+        training = TrainingMeta()
+
+    training_meta: dict[str, object] = {
+        "schema_version": 1,
+        "scenario_name": training.scenario_name,
+        "algorithm": training.algorithm,
+        "obs_depth": training.obs_depth,
+        "sample_rate": training.sample_rate,
+        "model_type": training.model_type,
+        "exported_at": datetime.now(UTC).isoformat(),
+    }
+    if training.output_mode is not None:
+        training_meta["output_mode"] = training.output_mode
+    if training.action_map is not None:
+        training_meta["action_map"] = training.action_map
+
+    # koios.bindings
+    input_dicts = []
+    for i, inp in enumerate(inputs):
+        entry: dict[str, object] = {
+            "binding_order": i + 1,
+            "name": inp.name,
+            "description": inp.description,
+        }
+        if inp.normalization_type != "none":
+            entry["normalization_type"] = inp.normalization_type
+            if inp.normalization_source is not None:
+                entry["normalization_source"] = inp.normalization_source
+            if inp.custom_mean is not None:
+                entry["custom_mean"] = inp.custom_mean
+            if inp.custom_std is not None:
+                entry["custom_std"] = inp.custom_std
+            if inp.custom_minimum is not None:
+                entry["custom_minimum"] = inp.custom_minimum
+            if inp.custom_maximum is not None:
+                entry["custom_maximum"] = inp.custom_maximum
+        if inp.custom_failure:
+            entry["custom_failure"] = True
+            if inp.custom_failure_minimum is not None:
+                entry["custom_failure_minimum"] = inp.custom_failure_minimum
+            if inp.custom_failure_maximum is not None:
+                entry["custom_failure_maximum"] = inp.custom_failure_maximum
+        input_dicts.append(entry)
+
+    output_dicts = []
+    for i, out in enumerate(outputs):
+        entry = {
+            "binding_order": i + 1,
+            "name": out.name,
+            "description": out.description,
+            "normalization_type": out.normalization_type,
+        }
+        if out.range_min is not None:
+            entry["range_min"] = out.range_min
+        if out.range_max is not None:
+            entry["range_max"] = out.range_max
+        if out.normalization_source is not None:
+            entry["normalization_source"] = out.normalization_source
+        if out.custom_minimum is not None:
+            entry["custom_minimum"] = out.custom_minimum
+        if out.custom_maximum is not None:
+            entry["custom_maximum"] = out.custom_maximum
+        if out.clamp_output:
+            entry["clamp_output"] = True
+        output_dicts.append(entry)
+
+    bindings_meta: dict[str, object] = {
+        "schema_version": 1,
+        "output_denormalized": False,
+        "obs_normalized": False,
+        "inputs": input_dicts,
+        "outputs": output_dicts,
+    }
+
+    onnx_model.metadata_props.append(
+        onnx.StringStringEntryProto(key="koios.training", value=json.dumps(training_meta))
+    )
+    onnx_model.metadata_props.append(
+        onnx.StringStringEntryProto(key="koios.bindings", value=json.dumps(bindings_meta))
+    )
+
+    print(f"Embedded koios.training metadata ({len(inputs)} inputs, {len(outputs)} outputs)")
+
+
+# ---------------------------------------------------------------------------
+# Convenience builders
+# ---------------------------------------------------------------------------
+
+
+def build_input_bindings(
+    obs_nodes: list[str],
+    *,
+    descriptions: dict[str, str] | None = None,
+    obs_stats: tuple[np.ndarray, np.ndarray, float, float] | None = None,
+    obs_norm_minmax: tuple[np.ndarray, np.ndarray] | None = None,
+    obs_range: tuple[np.ndarray, np.ndarray] | None = None,
+) -> list[InputBinding]:
+    """Build InputBinding list from node names + optional normalization stats.
+
+    Parameters
+    ----------
+    obs_nodes:
+        Observation node names (one per feature).
+    descriptions:
+        Optional ``{node_name: description}`` mapping.
+    obs_stats:
+        Optional ``(mean, var, clip, epsilon)`` from VecNormalize.  When
+        provided, Z-Score normalization parameters are computed per feature.
+        If the stats have shape ``(obs_depth, num_features)``, they are
+        averaged across depth positions.
+    obs_norm_minmax:
+        Optional ``(obs_mins, obs_maxs)`` per-feature arrays for min/max
+        normalization.  When provided (and ``obs_stats`` is not), sets
+        ``normalization_type="min_max"`` with ``custom_minimum``/``custom_maximum``.
+    obs_range:
+        Optional ``(obs_min, obs_max)`` per-feature arrays from training.
+        When provided, failure bounds are set per input binding.
+    """
+    desc = descriptions or {}
+    num_features = len(obs_nodes)
+
+    # Compute per-feature mean/std from VecNormalize stats
+    feature_mean: np.ndarray | None = None
+    feature_std: np.ndarray | None = None
+    if obs_stats is not None:
+        mean_np, var_np, _clip, epsilon = obs_stats
+        if mean_np.ndim == 2:
+            feature_mean = mean_np.mean(axis=0)
+            feature_std = np.sqrt(var_np.mean(axis=0) + epsilon)
+        elif mean_np.size > num_features:
+            obs_depth = mean_np.size // num_features
+            mean_2d = mean_np.reshape(obs_depth, num_features)
+            var_2d = var_np.reshape(obs_depth, num_features)
+            feature_mean = mean_2d.mean(axis=0)
+            feature_std = np.sqrt(var_2d.mean(axis=0) + epsilon)
+        else:
+            feature_mean = mean_np.ravel()
+            feature_std = np.sqrt(var_np.ravel() + epsilon)
+
+    bindings = []
+    for i, name in enumerate(obs_nodes):
+        b = InputBinding(name=name, description=desc.get(name, ""))
+        if feature_mean is not None and feature_std is not None:
+            b.normalization_type = "z_score"
+            b.normalization_source = "custom"
+            b.custom_mean = float(feature_mean[i])
+            b.custom_std = float(feature_std[i])
+        elif obs_norm_minmax is not None:
+            obs_mins, obs_maxs = obs_norm_minmax
+            b.normalization_type = "min_max"
+            b.normalization_source = "custom"
+            b.custom_minimum = float(obs_mins[i])
+            b.custom_maximum = float(obs_maxs[i])
+        if obs_range is not None:
+            obs_min, obs_max = obs_range
+            b.custom_failure = True
+            b.custom_failure_minimum = float(obs_min[i])
+            b.custom_failure_maximum = float(obs_max[i])
+        bindings.append(b)
+
+    return bindings
+
+
+def build_output_bindings(
+    action_nodes: list[str],
+    action_ranges: dict[str, tuple[float, float]],
+    *,
+    descriptions: dict[str, str] | None = None,
+    discrete: bool = False,
+) -> list[OutputBinding]:
+    """Build OutputBinding list from action node names + ranges.
+
+    Parameters
+    ----------
+    action_nodes:
+        Action node names.
+    action_ranges:
+        ``{node_name: (low, high)}`` action space bounds.
+    descriptions:
+        Optional ``{node_name: description}`` mapping.
+    discrete:
+        If True, outputs get ``normalization_type="none"`` (DQN models).
+    """
+    desc = descriptions or {}
+    bindings = []
+    for name in action_nodes:
+        if discrete:
+            bindings.append(
+                OutputBinding(
+                    name=name,
+                    description=desc.get(name, ""),
+                    normalization_type="none",
+                )
+            )
+        else:
+            lo, hi = action_ranges[name]
+            bindings.append(
+                OutputBinding(
+                    name=name,
+                    description=desc.get(name, ""),
+                    range_min=lo,
+                    range_max=hi,
+                    normalization_type="symmetric",
+                    normalization_source="custom",
+                    custom_minimum=lo,
+                    custom_maximum=hi,
+                    clamp_output=True,
+                )
+            )
+
+    return bindings

koios_model_utils-1.0.0rc1.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: koios-model-utils
+Version: 1.0.0rc1
+Summary: Utilities for exporting and annotating ONNX models for the Koios IoT platform
+Project-URL: Homepage, https://www.ai-op.com
+Project-URL: Documentation, https://github.com/Ai-Ops-Inc/koios-model-utils
+Project-URL: Repository, https://github.com/Ai-Ops-Inc/koios-model-utils
+Project-URL: Issues, https://github.com/Ai-Ops-Inc/koios-model-utils/issues
+Author-email: "Ai-OPs, Inc." <support@ai-op.com>
+License: MIT
+License-File: LICENSE
+Keywords: industrial,iot,koios,machine-learning,onnx,reinforcement-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: numpy
+Requires-Dist: onnx>=1.14
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Provides-Extra: sb3
+Requires-Dist: onnxruntime>=1.16; extra == 'sb3'
+Requires-Dist: onnxscript; extra == 'sb3'
+Requires-Dist: stable-baselines3>=2.0; extra == 'sb3'
+Requires-Dist: torch; extra == 'sb3'
+Description-Content-Type: text/markdown
+
+# koios-model-utils
+
+Utilities for exporting and annotating ONNX models for the [Koios](https://ai-op.com) IoT platform.
+
+This package helps data scientists prepare trained ML models (especially Stable-Baselines3 reinforcement learning models) for deployment on Koios. It handles ONNX export, metadata embedding, and normalization parameter annotation so the Koios Predict Engine can run inference correctly.
+
+## Installation
+
+```bash
+# Metadata embedding only (no torch/SB3 dependency)
+pip install koios-model-utils
+
+# Full SB3 export pipeline
+pip install koios-model-utils[sb3]
+```
+
+## Quick Start
+
+### Embed metadata into an existing ONNX model
+
+```python
+import onnx
+from koios_model_utils import (
+    InputBinding, OutputBinding, TrainingMeta,
+    embed_koios_metadata,
+)
+
+model = onnx.load("my_model.onnx")
+
+inputs = [
+    InputBinding(name="temperature", description="Tank temperature (C)"),
+    InputBinding(name="pressure", description="Vessel pressure (kPa)"),
+]
+outputs = [
+    OutputBinding(
+        name="valve_position",
+        range_min=0.0, range_max=100.0,
+        normalization_type="symmetric",
+        normalization_source="custom",
+        custom_minimum=0.0, custom_maximum=100.0,
+        clamp_output=True,
+    ),
+]
+training = TrainingMeta(
+    scenario_name="tank_temperature",
+    algorithm="PPO",
+    obs_depth=5,
+    sample_rate=1.0,
+)
+
+embed_koios_metadata(model, inputs=inputs, outputs=outputs, training=training)
+onnx.save(model, "my_model_koios.onnx")
+```
+
+### Export an SB3 model to ONNX
+
+```python
+from koios_model_utils import export_onnx, build_input_bindings, build_output_bindings, TrainingMeta
+
+inputs = build_input_bindings(
+    ["temperature", "level", "flow_rate"],
+    descriptions={"temperature": "Tank temp (C)", "level": "Tank level (%)"},
+)
+outputs = build_output_bindings(
+    ["valve_position"],
+    action_ranges={"valve_position": (0.0, 100.0)},
+)
+
+export_onnx(
+    "runs/best_model.zip",
+    inputs=inputs,
+    outputs=outputs,
+    training=TrainingMeta(scenario_name="tank_temperature", algorithm="PPO", obs_depth=5),
+)
+```
+
+### CLI
+
+```bash
+# Export with auto-detected settings
+koios-export runs/best_model.zip
+
+# Specify output path and opset version
+koios-export runs/best_model.zip --output model.onnx --opset 18
+```
+
+## SB3 Training Callbacks
+
+```python
+from koios_model_utils import ObsRangeCallback, VecNormalizeSyncCallback
+
+# Track observation ranges during training
+obs_range_cb = ObsRangeCallback(run_dir, verbose=1)
+
+# Sync VecNormalize stats with best model checkpoints
+vec_sync_cb = VecNormalizeSyncCallback(eval_callback, verbose=1)
+```
+
+## API Reference
+
+### Metadata Types
+
+| Class | Description |
+|-------|-------------|
+| `InputBinding` | Describes one input (observation) binding — name, normalization, failure bounds |
+| `OutputBinding` | Describes one output (action) binding — name, range, normalization, clamping |
+| `TrainingMeta` | Model-level metadata — algorithm, obs_depth, sample_rate, model_type |
+
+### Functions
+
+| Function | Description |
+|----------|-------------|
+| `embed_koios_metadata()` | Embed `koios.training` and `koios.bindings` metadata into an ONNX model |
+| `build_input_bindings()` | Build input bindings from node names + optional normalization stats |
+| `build_output_bindings()` | Build output bindings from action names + ranges |
+| `export_onnx()` | Full SB3-to-ONNX export pipeline (requires `[sb3]` extra) |
+| `detect_algorithm()` | Detect SB3 algorithm (PPO, SAC, TD3, etc.) from a saved `.zip` model |
+
+### Callbacks (requires `[sb3]` extra)
+
+| Callback | Description |
+|----------|-------------|
+| `ObsRangeCallback` | Track per-feature min/max of observations during training |
+| `VecNormalizeSyncCallback` | Save VecNormalize stats alongside best model checkpoints |
+
+## Development
+
+```bash
+# Install with all dependencies
+pip install -e ".[sb3,dev]"
+
+# Run tests
+make test
+
+# Lint
+make lint
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.

koios_model_utils-1.0.0rc1.dist-info/RECORD

@@ -0,0 +1,10 @@
+koios_model_utils/__init__.py,sha256=cIXywPWyjiPOXZdIG15FSRA6QoK6TJJTaYQ0uDFk4Jk,1152
+koios_model_utils/callbacks.py,sha256=v9teVKDjhSZLIPVK9blqBPp56u1mL0F4VGZ7VOo-GQM,5556
+koios_model_utils/export.py,sha256=dg8U587MThA-YtT_kItq_QhJTL26viRPfVjR80wBF68,24221
+koios_model_utils/metadata.py,sha256=Y_oIUmH42SVju7M3PGbXwZb2Coh5pqfE0z-3axXQxNU,10518
+koios_model_utils/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+koios_model_utils-1.0.0rc1.dist-info/METADATA,sha256=Iv7CwRhnSNHmj8PbQ6EzHaddMswBclnQkOgHgkIL4EQ,5471
+koios_model_utils-1.0.0rc1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+koios_model_utils-1.0.0rc1.dist-info/entry_points.txt,sha256=qWYPe_ewlenHyXtl9WDhUbU8QfkHYjPOqPZRDi9BgEc,63
+koios_model_utils-1.0.0rc1.dist-info/licenses/LICENSE,sha256=gLwtrbMu-rRAs0ddzfXVcJm9VvgFiowC_IKcSBt00kE,1074
+koios_model_utils-1.0.0rc1.dist-info/RECORD,,

koios_model_utils-1.0.0rc1.dist-info/WHEEL

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

koios_model_utils-1.0.0rc1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+koios-export = koios_model_utils.export:main

koios_model_utils-1.0.0rc1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2026 Ai-OPs, Inc.
+
+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.