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

ins_pricing_gemini/modelling/notebook_utils.py

@@ -1,294 +0,0 @@
-from __future__ import annotations
-
-import json
-import subprocess
-import sys
-from pathlib import Path
-from typing import Iterable, List, Optional, Sequence, cast
-
-
-def _find_ins_pricing_dir(cwd: Optional[Path] = None) -> Path:
-    cwd = (cwd or Path().resolve()).resolve()
-    # If running from root/scripts or root
-    candidates = [cwd, cwd.parent, cwd / "ins_pricing", cwd.parent / "ins_pricing"]
-    for cand in candidates:
-        # Check for modelling/core.py in root (since we restructured)
-        if (cand / "modelling" / "core.py").exists() and (cand / "scripts" / "train.py").exists():
-            return cand
-    
-    # Fallback: try finding package via file path if inside package
-    # If this file is in modelling/, parent is modelling, parent.parent is root (ins_pricing package dir or root of repo)
-    pkg_dir = Path(__file__).resolve().parent.parent
-    if (pkg_dir / "modelling" / "core.py").exists():
-         return pkg_dir
-         
-    raise FileNotFoundError(
-        "Cannot locate ins_pricing root directory (expected modelling/core.py and scripts/train.py). "
-        f"cwd={cwd}"
-    )
-
-
-def _stringify_cmd(cmd: Sequence[object]) -> List[str]:
-    return [str(x) for x in cmd]
-
-
-def build_bayesopt_entry_cmd(
-    config_json: str | Path,
-    model_keys: Sequence[str],
-    *,
-    nproc_per_node: int = 1,
-    standalone: bool = True,
-    entry_script: str | Path = "scripts/train.py",
-    extra_args: Optional[Sequence[str]] = None,
-) -> List[str]:
-    """Build a command to run train.py (optional torchrun/DDP)."""
-    pkg_dir = _find_ins_pricing_dir()
-    entry_script_path = Path(entry_script)
-    if entry_script_path.is_absolute():
-        entry_path = entry_script_path.resolve()
-    else:
-        # Check relative to root
-        entry_path = (pkg_dir / entry_script_path).resolve()
-    
-    config_path = Path(config_json)
-    if not config_path.is_absolute():
-        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
-
-    cmd: List[object]
-    if int(nproc_per_node) > 1:
-        cmd = [
-            sys.executable,
-            "-m",
-            "torch.distributed.run",
-            *(["--standalone"] if standalone else []),
-            f"--nproc_per_node={int(nproc_per_node)}",
-            str(entry_path),
-        ]
-    else:
-        cmd = [sys.executable, str(entry_path)]
-
-    cmd += ["--config-json", str(config_path), "--model-keys", *list(model_keys)]
-    if extra_args:
-        cmd += list(extra_args)
-    return _stringify_cmd(cmd)
-
-
-def build_incremental_cmd(
-    config_json: str | Path,
-    *,
-    entry_script: str | Path = "scripts/BayesOpt_incremental.py",
-    extra_args: Optional[Sequence[str]] = None,
-) -> List[str]:
-    """Build a command to run BayesOpt_incremental.py."""
-    pkg_dir = _find_ins_pricing_dir()
-    entry_script_path = Path(entry_script)
-    if entry_script_path.is_absolute():
-        entry_path = entry_script_path.resolve()
-    else:
-        entry_path = (pkg_dir / entry_script_path).resolve()
-        
-    config_path = Path(config_json)
-    if not config_path.is_absolute():
-        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
-
-    cmd: List[object] = [sys.executable, str(entry_path), "--config-json", str(config_path)]
-    if extra_args:
-        cmd += list(extra_args)
-    return _stringify_cmd(cmd)
-
-
-def build_explain_cmd(
-    config_json: str | Path,
-    *,
-    entry_script: str | Path = "scripts/Explain_entry.py",
-    extra_args: Optional[Sequence[str]] = None,
-) -> List[str]:
-    """Build a command to run Explain_entry.py."""
-    pkg_dir = _find_ins_pricing_dir()
-    entry_script_path = Path(entry_script)
-    if entry_script_path.is_absolute():
-        entry_path = entry_script_path.resolve()
-    else:
-        entry_path = (pkg_dir / entry_script_path).resolve()
-
-    config_path = Path(config_json)
-    if not config_path.is_absolute():
-        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
-
-    cmd: List[object] = [sys.executable, str(entry_path), "--config-json", str(config_path)]
-    if extra_args:
-        cmd += list(extra_args)
-    return _stringify_cmd(cmd)
-
-
-def wrap_with_watchdog(
-    cmd: Sequence[str],
-    *,
-    idle_seconds: int = 7200,
-    max_restarts: int = 50,
-    restart_delay_seconds: int = 10,
-    stop_on_nonzero_exit: bool = True,
-    watchdog_script: str | Path = "watchdog_run.py",
-) -> List[str]:
-    """Wrap a command with watchdog: restart when idle_seconds elapses with no output."""
-    pkg_dir = _find_ins_pricing_dir()
-    watchdog_script_path = Path(watchdog_script)
-    if watchdog_script_path.is_absolute():
-        watchdog_path = watchdog_script_path.resolve()
-    else:
-        # watchdog_run.py is in root
-        watchdog_path = (pkg_dir / watchdog_script_path).resolve()
-        
-    wd_cmd: List[object] = [
-        sys.executable,
-        str(watchdog_path),
-        "--idle-seconds",
-        str(int(idle_seconds)),
-        "--max-restarts",
-        str(int(max_restarts)),
-        "--restart-delay-seconds",
-        str(int(restart_delay_seconds)),
-    ]
-    if stop_on_nonzero_exit:
-        wd_cmd.append("--stop-on-nonzero-exit")
-    wd_cmd.append("--")
-    wd_cmd.extend(list(cmd))
-    return _stringify_cmd(wd_cmd)
-
-
-def run(cmd: Sequence[str], *, check: bool = True) -> subprocess.CompletedProcess:
-    """Run an external command from a notebook (blocking)."""
-    return subprocess.run(list(cmd), check=check)
-
-
-def run_bayesopt_entry(
-    *,
-    config_json: str | Path,
-    model_keys: Sequence[str],
-    max_evals: int = 50,
-    plot_curves: bool = True,
-    ft_role: Optional[str] = None,
-    nproc_per_node: int = 1,
-    use_watchdog: bool = False,
-    idle_seconds: int = 7200,
-    max_restarts: int = 50,
-    restart_delay_seconds: int = 10,
-    extra_args: Optional[Sequence[str]] = None,
-) -> subprocess.CompletedProcess:
-    """Convenience wrapper: build and run BayesOpt_entry (optional torchrun + watchdog)."""
-    args: List[str] = ["--max-evals", str(int(max_evals))]
-    if plot_curves:
-        args.append("--plot-curves")
-    if ft_role:
-        args += ["--ft-role", str(ft_role)]
-    if extra_args:
-        args += list(extra_args)
-
-    cmd = build_bayesopt_entry_cmd(
-        config_json=config_json,
-        model_keys=model_keys,
-        nproc_per_node=nproc_per_node,
-        extra_args=args,
-    )
-    if use_watchdog:
-        cmd = wrap_with_watchdog(
-            cmd,
-            idle_seconds=idle_seconds,
-            max_restarts=max_restarts,
-            restart_delay_seconds=restart_delay_seconds,
-        )
-    return run(cmd, check=True)
-
-
-def run_from_config(config_json: str | Path) -> subprocess.CompletedProcess:
-    """Notebook entry point: switch execution modes by editing config.json.
-
-    Convention: config.json may include a `runner` section for notebook control:
-    - runner.mode: "entry" (default), "incremental", or "explain"
-    - runner.nproc_per_node: >1 enables torchrun/DDP (entry only)
-    - runner.model_keys: list of models to run (entry only)
-    - runner.max_evals / runner.plot_curves / runner.ft_role (entry only; override config fields)
-    - runner.use_watchdog / runner.idle_seconds / runner.max_restarts / runner.restart_delay_seconds
-    - runner.incremental_args: List[str] (incremental only; extra args for BayesOpt_incremental.py)
-    """
-    pkg_dir = _find_ins_pricing_dir()
-    config_path = Path(config_json)
-    if not config_path.is_absolute():
-        config_path = (pkg_dir / config_path).resolve() if (pkg_dir / config_path).exists() else config_path.resolve()
-    raw = json.loads(config_path.read_text(encoding="utf-8", errors="replace"))
-    runner = cast(dict, raw.get("runner") or {})
-
-    mode = str(runner.get("mode") or "entry").strip().lower()
-    use_watchdog = bool(runner.get("use_watchdog", False))
-    idle_seconds = int(runner.get("idle_seconds", 7200))
-    max_restarts = int(runner.get("max_restarts", 50))
-    restart_delay_seconds = int(runner.get("restart_delay_seconds", 10))
-
-    if mode == "incremental":
-        inc_args = runner.get("incremental_args") or []
-        if not isinstance(inc_args, list):
-            raise ValueError("config.runner.incremental_args must be a list of strings.")
-        cmd = build_incremental_cmd(config_path, extra_args=[str(x) for x in inc_args])
-        if use_watchdog:
-            cmd = wrap_with_watchdog(
-                cmd,
-                idle_seconds=idle_seconds,
-                max_restarts=max_restarts,
-                restart_delay_seconds=restart_delay_seconds,
-            )
-        return run(cmd, check=True)
-
-    if mode == "explain":
-        exp_args = runner.get("explain_args") or []
-        if not isinstance(exp_args, list):
-            raise ValueError("config.runner.explain_args must be a list of strings.")
-        cmd = build_explain_cmd(config_path, extra_args=[str(x) for x in exp_args])
-        if use_watchdog:
-            cmd = wrap_with_watchdog(
-                cmd,
-                idle_seconds=idle_seconds,
-                max_restarts=max_restarts,
-                restart_delay_seconds=restart_delay_seconds,
-            )
-        return run(cmd, check=True)
-
-    if mode != "entry":
-        raise ValueError(
-            f"Unsupported runner.mode={mode!r}, expected 'entry', 'incremental', or 'explain'."
-        )
-
-    model_keys = runner.get("model_keys")
-    if not model_keys:
-        model_keys = raw.get("model_keys")
-    if not model_keys:
-        model_keys = ["ft"]
-    if not isinstance(model_keys, list):
-        raise ValueError("runner.model_keys must be a list of strings.")
-
-    nproc_per_node = int(runner.get("nproc_per_node", 1))
-    max_evals = int(runner.get("max_evals", raw.get("max_evals", 50)))
-    plot_curves = bool(runner.get("plot_curves", raw.get("plot_curves", True)))
-    ft_role = runner.get("ft_role", None)
-    if ft_role is None:
-        ft_role = raw.get("ft_role")
-
-    cmd = build_bayesopt_entry_cmd(
-        config_path,
-        model_keys=[str(x) for x in model_keys],
-        nproc_per_node=nproc_per_node,
-        extra_args=[
-            "--max-evals",
-            str(max_evals),
-            *(["--plot-curves"] if plot_curves else []),
-            *(["--ft-role", str(ft_role)] if ft_role else []),
-        ],
-    )
-
-    if use_watchdog:
-        cmd = wrap_with_watchdog(
-            cmd,
-            idle_seconds=idle_seconds,
-            max_restarts=max_restarts,
-            restart_delay_seconds=restart_delay_seconds,
-        )
-    return run(cmd, check=True)

ins_pricing_gemini/modelling/plotting/__init__.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-from .common import EPS, PlotStyle
-from .curves import (
-    double_lift_table,
-    lift_table,
-    plot_calibration_curve,
-    plot_conversion_lift,
-    plot_double_lift_curve,
-    plot_ks_curve,
-    plot_lift_curve,
-    plot_pr_curves,
-    plot_roc_curves,
-)
-from .diagnostics import plot_loss_curve, plot_oneway
-from .geo import (
-    plot_geo_contour,
-    plot_geo_contour_on_map,
-    plot_geo_heatmap,
-    plot_geo_heatmap_on_map,
-)
-from .importance import plot_feature_importance, plot_shap_importance, shap_importance
-
-__all__ = [
-    "EPS",
-    "PlotStyle",
-    "double_lift_table",
-    "lift_table",
-    "plot_calibration_curve",
-    "plot_conversion_lift",
-    "plot_double_lift_curve",
-    "plot_feature_importance",
-    "plot_geo_contour",
-    "plot_geo_contour_on_map",
-    "plot_geo_heatmap",
-    "plot_geo_heatmap_on_map",
-    "plot_ks_curve",
-    "plot_lift_curve",
-    "plot_loss_curve",
-    "plot_oneway",
-    "plot_pr_curves",
-    "plot_roc_curves",
-    "plot_shap_importance",
-    "shap_importance",
-]

ins_pricing_gemini/modelling/plotting/common.py

@@ -1,63 +0,0 @@
-from __future__ import annotations
-
-import os
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Optional, Sequence, Tuple
-
-import matplotlib
-
-if os.name != "nt" and not os.environ.get("DISPLAY") and not os.environ.get("MPLBACKEND"):
-    matplotlib.use("Agg")
-import matplotlib.pyplot as plt
-
-EPS = 1e-8
-
-
-@dataclass(frozen=True)
-class PlotStyle:
-    figsize: Tuple[float, float] = (8.0, 4.5)
-    dpi: int = 300
-    palette: Sequence[str] = (
-        "#1f77b4",
-        "#ff7f0e",
-        "#2ca02c",
-        "#d62728",
-        "#9467bd",
-        "#8c564b",
-        "#e377c2",
-        "#7f7f7f",
-        "#bcbd22",
-        "#17becf",
-    )
-    grid: bool = True
-    grid_alpha: float = 0.3
-    grid_style: str = "--"
-    title_size: int = 10
-    label_size: int = 8
-    tick_size: int = 7
-    legend_size: int = 7
-    weight_color: str = "seagreen"
-
-
-def ensure_parent_dir(path: str | Path) -> None:
-    target = Path(path).expanduser().resolve()
-    target.parent.mkdir(parents=True, exist_ok=True)
-
-
-def finalize_figure(
-    fig: plt.Figure,
-    *,
-    save_path: Optional[str] = None,
-    show: bool = False,
-    close: bool = True,
-    style: Optional[PlotStyle] = None,
-) -> None:
-    if save_path:
-        ensure_parent_dir(save_path)
-        dpi = style.dpi if style else 300
-        fig.savefig(save_path, dpi=dpi, bbox_inches="tight")
-    if show:
-        plt.show()
-    if close:
-        plt.close(fig)