ins-pricing 0.1.11__py3-none-any.whl → 0.2.0__py3-none-any.whl

ins_pricing_gemini/governance/approval.py

@@ -1,93 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import asdict, dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional
-
-
-@dataclass
-class ApprovalAction:
-    actor: str
-    decision: str
-    timestamp: str
-    comment: Optional[str] = None
-
-
-@dataclass
-class ApprovalRequest:
-    model_name: str
-    model_version: str
-    requested_by: str
-    requested_at: str
-    status: str = "pending"
-    actions: List[ApprovalAction] = field(default_factory=list)
-
-
-class ApprovalStore:
-    """Simple approval workflow stored as JSON."""
-
-    def __init__(self, store_path: str | Path):
-        self.store_path = Path(store_path)
-        self.store_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def _load(self) -> List[dict]:
-        if not self.store_path.exists():
-            return []
-        with self.store_path.open("r", encoding="utf-8") as fh:
-            return json.load(fh)
-
-    def _save(self, payload: List[dict]) -> None:
-        with self.store_path.open("w", encoding="utf-8") as fh:
-            json.dump(payload, fh, indent=2, ensure_ascii=True)
-
-    def request(self, model_name: str, model_version: str, requested_by: str) -> ApprovalRequest:
-        payload = self._load()
-        req = ApprovalRequest(
-            model_name=model_name,
-            model_version=model_version,
-            requested_by=requested_by,
-            requested_at=datetime.utcnow().isoformat(),
-        )
-        payload.append(asdict(req))
-        self._save(payload)
-        return req
-
-    def list_requests(self, model_name: Optional[str] = None) -> List[ApprovalRequest]:
-        payload = self._load()
-        requests = [ApprovalRequest(**entry) for entry in payload]
-        if model_name is None:
-            return requests
-        return [req for req in requests if req.model_name == model_name]
-
-    def act(
-        self,
-        model_name: str,
-        model_version: str,
-        *,
-        actor: str,
-        decision: str,
-        comment: Optional[str] = None,
-    ) -> ApprovalRequest:
-        payload = self._load()
-        found = None
-        for entry in payload:
-            if entry["model_name"] == model_name and entry["model_version"] == model_version:
-                found = entry
-                break
-        if found is None:
-            raise ValueError("Approval request not found.")
-        action = ApprovalAction(
-            actor=actor,
-            decision=decision,
-            timestamp=datetime.utcnow().isoformat(),
-            comment=comment,
-        )
-        found["actions"].append(asdict(action))
-        if decision.lower() in {"approve", "approved"}:
-            found["status"] = "approved"
-        elif decision.lower() in {"reject", "rejected"}:
-            found["status"] = "rejected"
-        self._save(payload)
-        return ApprovalRequest(**found)

ins_pricing_gemini/governance/audit.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import asdict, dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Any, Dict, Optional
-
-
-@dataclass
-class AuditEvent:
-    action: str
-    actor: str
-    timestamp: str
-    metadata: Dict[str, Any]
-    note: Optional[str] = None
-
-
-class AuditLogger:
-    """Append-only JSONL audit log."""
-
-    def __init__(self, log_path: str | Path):
-        self.log_path = Path(log_path)
-        self.log_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def log(self, action: str, actor: str, *, metadata: Optional[Dict[str, Any]] = None,
-            note: Optional[str] = None) -> AuditEvent:
-        event = AuditEvent(
-            action=action,
-            actor=actor,
-            timestamp=datetime.utcnow().isoformat(),
-            metadata=metadata or {},
-            note=note,
-        )
-        with self.log_path.open("a", encoding="utf-8") as fh:
-            fh.write(json.dumps(asdict(event), ensure_ascii=True) + "\n")
-        return event

ins_pricing_gemini/governance/registry.py

@@ -1,99 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import asdict, dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, List, Optional
-
-
-@dataclass
-class ModelArtifact:
-    path: str
-    description: Optional[str] = None
-
-
-@dataclass
-class ModelVersion:
-    name: str
-    version: str
-    created_at: str
-    metrics: Dict[str, float] = field(default_factory=dict)
-    tags: Dict[str, str] = field(default_factory=dict)
-    artifacts: List[ModelArtifact] = field(default_factory=list)
-    status: str = "candidate"
-    notes: Optional[str] = None
-
-
-class ModelRegistry:
-    """Lightweight JSON-based model registry."""
-
-    def __init__(self, registry_path: str | Path):
-        self.registry_path = Path(registry_path)
-        self.registry_path.parent.mkdir(parents=True, exist_ok=True)
-
-    def _load(self) -> Dict[str, List[dict]]:
-        if not self.registry_path.exists():
-            return {}
-        with self.registry_path.open("r", encoding="utf-8") as fh:
-            return json.load(fh)
-
-    def _save(self, payload: Dict[str, List[dict]]) -> None:
-        with self.registry_path.open("w", encoding="utf-8") as fh:
-            json.dump(payload, fh, indent=2, ensure_ascii=True)
-
-    def register(
-        self,
-        name: str,
-        version: str,
-        *,
-        metrics: Optional[Dict[str, float]] = None,
-        tags: Optional[Dict[str, str]] = None,
-        artifacts: Optional[List[ModelArtifact]] = None,
-        status: str = "candidate",
-        notes: Optional[str] = None,
-    ) -> ModelVersion:
-        payload = self._load()
-        created_at = datetime.utcnow().isoformat()
-        entry = ModelVersion(
-            name=name,
-            version=version,
-            created_at=created_at,
-            metrics=metrics or {},
-            tags=tags or {},
-            artifacts=artifacts or [],
-            status=status,
-            notes=notes,
-        )
-        payload.setdefault(name, []).append(asdict(entry))
-        self._save(payload)
-        return entry
-
-    def list_versions(self, name: str) -> List[ModelVersion]:
-        payload = self._load()
-        versions = payload.get(name, [])
-        return [ModelVersion(**v) for v in versions]
-
-    def get_version(self, name: str, version: str) -> Optional[ModelVersion]:
-        for entry in self.list_versions(name):
-            if entry.version == version:
-                return entry
-        return None
-
-    def promote(
-        self, name: str, version: str, *, new_status: str = "production"
-    ) -> None:
-        payload = self._load()
-        if name not in payload:
-            raise ValueError("Model not found in registry.")
-        updated = False
-        for entry in payload[name]:
-            if entry["version"] == version:
-                entry["status"] = new_status
-                updated = True
-            elif new_status == "production":
-                if entry.get("status") == "production":
-                    entry["status"] = "archived"
-        if not updated:
-            raise ValueError("Version not found in registry.")
-        self._save(payload)

ins_pricing_gemini/governance/release.py

@@ -1,159 +0,0 @@
-from __future__ import annotations
-
-import json
-from dataclasses import asdict, dataclass, field
-from datetime import datetime
-from pathlib import Path
-from typing import List, Optional
-
-from .audit import AuditLogger
-from .registry import ModelRegistry
-
-
-@dataclass
-class ModelRef:
-    name: str
-    version: str
-    activated_at: str
-    actor: Optional[str] = None
-    note: Optional[str] = None
-
-
-@dataclass
-class DeploymentState:
-    env: str
-    active: Optional[ModelRef] = None
-    history: List[ModelRef] = field(default_factory=list)
-    updated_at: Optional[str] = None
-
-
-class ReleaseManager:
-    """Environment release manager with rollback support."""
-
-    def __init__(
-        self,
-        state_dir: str | Path,
-        *,
-        registry: Optional[ModelRegistry] = None,
-        audit_logger: Optional[AuditLogger] = None,
-    ):
-        self.state_dir = Path(state_dir)
-        self.state_dir.mkdir(parents=True, exist_ok=True)
-        self.registry = registry
-        self.audit_logger = audit_logger
-
-    def _state_path(self, env: str) -> Path:
-        return self.state_dir / f"{env}.json"
-
-    def _load(self, env: str) -> DeploymentState:
-        path = self._state_path(env)
-        if not path.exists():
-            return DeploymentState(env=env)
-        with path.open("r", encoding="utf-8") as fh:
-            payload = json.load(fh)
-        active = payload.get("active")
-        history = payload.get("history", [])
-        return DeploymentState(
-            env=payload.get("env", env),
-            active=ModelRef(**active) if active else None,
-            history=[ModelRef(**item) for item in history],
-            updated_at=payload.get("updated_at"),
-        )
-
-    def _save(self, state: DeploymentState) -> None:
-        payload = {
-            "env": state.env,
-            "active": asdict(state.active) if state.active else None,
-            "history": [asdict(item) for item in state.history],
-            "updated_at": state.updated_at,
-        }
-        path = self._state_path(state.env)
-        with path.open("w", encoding="utf-8") as fh:
-            json.dump(payload, fh, indent=2, ensure_ascii=True)
-
-    def get_active(self, env: str) -> Optional[ModelRef]:
-        state = self._load(env)
-        return state.active
-
-    def list_history(self, env: str) -> List[ModelRef]:
-        return self._load(env).history
-
-    def deploy(
-        self,
-        env: str,
-        name: str,
-        version: str,
-        *,
-        actor: Optional[str] = None,
-        note: Optional[str] = None,
-        update_registry_status: bool = True,
-        registry_status: str = "production",
-    ) -> DeploymentState:
-        state = self._load(env)
-        if state.active and state.active.name == name and state.active.version == version:
-            return state
-
-        if state.active is not None:
-            state.history.append(state.active)
-
-        now = datetime.utcnow().isoformat()
-        state.active = ModelRef(
-            name=name,
-            version=version,
-            activated_at=now,
-            actor=actor,
-            note=note,
-        )
-        state.updated_at = now
-        self._save(state)
-
-        if self.registry and update_registry_status:
-            self.registry.promote(name, version, new_status=registry_status)
-
-        if self.audit_logger:
-            self.audit_logger.log(
-                "deploy",
-                actor or "unknown",
-                metadata={"env": env, "name": name, "version": version},
-                note=note,
-            )
-
-        return state
-
-    def rollback(
-        self,
-        env: str,
-        *,
-        actor: Optional[str] = None,
-        note: Optional[str] = None,
-        update_registry_status: bool = False,
-        registry_status: str = "production",
-    ) -> DeploymentState:
-        state = self._load(env)
-        if not state.history:
-            raise ValueError("No history available to rollback.")
-
-        previous = state.history.pop()
-        now = datetime.utcnow().isoformat()
-        state.active = ModelRef(
-            name=previous.name,
-            version=previous.version,
-            activated_at=now,
-            actor=actor or previous.actor,
-            note=note or previous.note,
-        )
-        state.updated_at = now
-        self._save(state)
-
-        if self.registry and update_registry_status:
-            self.registry.promote(previous.name, previous.version, new_status=registry_status)
-
-        if self.audit_logger:
-            self.audit_logger.log(
-                "rollback",
-                actor or "unknown",
-                metadata={"env": env, "name": previous.name, "version": previous.version},
-                note=note,
-            )
-
-        return state

ins_pricing_gemini/modelling/Explain_Run.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-from typing import Optional
-
-try:
-    from .notebook_utils import run_from_config  # type: ignore
-except Exception:  # pragma: no cover
-    from notebook_utils import run_from_config  # type: ignore
-
-
-def run(config_json: str | Path) -> None:
-    """Run explain by config.json (runner.mode=explain)."""
-    run_from_config(config_json)
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Explain_Run: run explain by config.json (runner.mode=explain)."
-    )
-    parser.add_argument(
-        "--config-json",
-        required=True,
-        help="Path to config.json (relative paths are resolved from ins_pricing/modelling/ when possible).",
-    )
-    return parser
-
-
-def main(argv: Optional[list[str]] = None) -> None:
-    args = _build_parser().parse_args(argv)
-    run(args.config_json)
-
-
-if __name__ == "__main__":
-    main()

ins_pricing_gemini/modelling/Pricing_Run.py

@@ -1,36 +0,0 @@
-from __future__ import annotations
-
-import argparse
-from pathlib import Path
-from typing import Optional
-
-try:
-    from .notebook_utils import run_from_config  # type: ignore
-except Exception:  # pragma: no cover
-    from notebook_utils import run_from_config  # type: ignore
-
-
-def run(config_json: str | Path) -> None:
-    """Unified entry point: run entry/incremental/watchdog/DDP based on config.json runner."""
-    run_from_config(config_json)
-
-
-def _build_parser() -> argparse.ArgumentParser:
-    parser = argparse.ArgumentParser(
-        description="Pricing_Run: run BayesOpt by config.json (entry/incremental/watchdog/DDP)."
-    )
-    parser.add_argument(
-        "--config-json",
-        required=True,
-        help="Path to config.json (relative paths are resolved from ins_pricing/modelling/ when possible).",
-    )
-    return parser
-
-
-def main(argv: Optional[list[str]] = None) -> None:
-    args = _build_parser().parse_args(argv)
-    run(args.config_json)
-
-
-if __name__ == "__main__":
-    main()

ins_pricing_gemini/modelling/__init__.py

@@ -1,151 +0,0 @@
-"""Modelling subpackage for ins_pricing."""
-
-from __future__ import annotations
-import types
-import sys
-from importlib import import_module
-from pathlib import Path
-
-# Exports
-from .config import BayesOptConfig
-from .config_preprocess import (
-    DatasetPreprocessor,
-    OutputManager,
-    VersionManager,
-)
-from .core import BayesOptModel
-from .models import (
-    FeatureTokenizer,
-    FTTransformerCore,
-    FTTransformerSklearn,
-    GraphNeuralNetSklearn,
-    MaskedTabularDataset,
-    ResBlock,
-    ResNetSequential,
-    ResNetSklearn,
-    ScaledTransformerEncoderLayer,
-    SimpleGraphLayer,
-    SimpleGNN,
-    TabularDataset,
-)
-from .trainers import (
-    FTTrainer,
-    GLMTrainer,
-    GNNTrainer,
-    ResNetTrainer,
-    TrainerBase,
-    XGBTrainer,
-    _xgb_cuda_available,
-)
-from .utils import (
-    EPS,
-    DistributedUtils,
-    IOUtils,
-    PlotUtils,
-    TorchTrainerMixin,
-    TrainingUtils,
-    compute_batch_size,
-    csv_to_dict,
-    ensure_parent_dir,
-    free_cuda,
-    infer_factor_and_cate_list,
-    plot_dlift_list,
-    plot_lift_list,
-    set_global_seed,
-    split_data,
-    tweedie_loss,
-)
-try:
-    import torch
-except ImportError:
-    torch = None
-
-# Lazy submodules
-_LAZY_SUBMODULES = {
-    "plotting": "ins_pricing.modelling.plotting",
-    "explain": "ins_pricing.modelling.explain",
-    "cli_common": "ins_pricing.modelling.cli_common",
-    "notebook_utils": "ins_pricing.modelling.notebook_utils",
-}
-
-_PACKAGE_PATHS = {
-    "plotting": Path(__file__).resolve().parent / "plotting",
-    "explain": Path(__file__).resolve().parent / "explain",
-}
-
-__all__ = [
-    "BayesOptConfig",
-    "DatasetPreprocessor",
-    "OutputManager",
-    "VersionManager",
-    "BayesOptModel",
-    "FeatureTokenizer",
-    "FTTransformerCore",
-    "FTTransformerSklearn",
-    "GraphNeuralNetSklearn",
-    "MaskedTabularDataset",
-    "ResBlock",
-    "ResNetSequential",
-    "ResNetSklearn",
-    "ScaledTransformerEncoderLayer",
-    "SimpleGraphLayer",
-    "SimpleGNN",
-    "TabularDataset",
-    "FTTrainer",
-    "GLMTrainer",
-    "GNNTrainer",
-    "ResNetTrainer",
-    "TrainerBase",
-    "XGBTrainer",
-    "_xgb_cuda_available",
-    "EPS",
-    "DistributedUtils",
-    "IOUtils",
-    "PlotUtils",
-    "TorchTrainerMixin",
-    "TrainingUtils",
-    "compute_batch_size",
-    "csv_to_dict",
-    "ensure_parent_dir",
-    "free_cuda",
-    "infer_factor_and_cate_list",
-    "plot_dlift_list",
-    "plot_lift_list",
-    "set_global_seed",
-    "split_data",
-    "tweedie_loss",
-    "torch",
-] + sorted(list(_LAZY_SUBMODULES.keys()))
-
-def _lazy_module(name: str, target: str, package_path: Path | None = None) -> types.ModuleType:
-    proxy = types.ModuleType(name)
-    if package_path is not None:
-        proxy.__path__ = [str(package_path)]
-
-    def _load():
-        module = import_module(target)
-        sys.modules[name] = module
-        return module
-
-    def __getattr__(attr: str):
-        module = _load()
-        return getattr(module, attr)
-
-    def __dir__() -> list[str]:
-        module = _load()
-        return sorted(set(dir(module)))
-
-    proxy.__getattr__ = __getattr__  # type: ignore[attr-defined]
-    proxy.__dir__ = __dir__  # type: ignore[attr-defined]
-    return proxy
-
-def _install_proxy(alias: str, target: str) -> None:
-    module_name = f"{__name__}.{alias}"
-    if module_name in sys.modules:
-        return
-    proxy = _lazy_module(module_name, target, _PACKAGE_PATHS.get(alias))
-    sys.modules[module_name] = proxy
-    globals()[alias] = proxy
-
-for _alias, _target in _LAZY_SUBMODULES.items():
-    _install_proxy(_alias, _target)