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

ins_pricing_gemini/production/monitoring.py

@@ -1,143 +0,0 @@
-from __future__ import annotations
-
-from typing import Dict, Iterable, Optional
-
-import numpy as np
-import pandas as pd
-
-
-def _safe_div(numer: float, denom: float, default: float = 0.0) -> float:
-    if denom == 0:
-        return default
-    return numer / denom
-
-
-def regression_metrics(
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    weight: Optional[np.ndarray] = None,
-) -> Dict[str, float]:
-    y_true = np.asarray(y_true, dtype=float).reshape(-1)
-    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
-    if weight is not None:
-        weight = np.asarray(weight, dtype=float).reshape(-1)
-        if weight.shape[0] != y_true.shape[0]:
-            raise ValueError("weight length must match y_true.")
-    err = y_true - y_pred
-    if weight is None:
-        mse = float(np.mean(err ** 2))
-        mae = float(np.mean(np.abs(err)))
-    else:
-        w_sum = float(np.sum(weight))
-        mse = float(np.sum(weight * (err ** 2)) / max(w_sum, 1.0))
-        mae = float(np.sum(weight * np.abs(err)) / max(w_sum, 1.0))
-    rmse = float(np.sqrt(mse))
-    denom = float(np.mean(y_true)) if np.mean(y_true) != 0 else 1.0
-    mape = float(np.mean(np.abs(err) / np.clip(np.abs(y_true), 1e-9, None)))
-    ss_tot = float(np.sum((y_true - np.mean(y_true)) ** 2))
-    ss_res = float(np.sum(err ** 2))
-    r2 = 1.0 - _safe_div(ss_res, ss_tot, default=0.0)
-    return {"rmse": rmse, "mae": mae, "mape": mape, "r2": r2}
-
-
-def loss_ratio(
-    actual_loss: np.ndarray,
-    predicted_premium: np.ndarray,
-    *,
-    weight: Optional[np.ndarray] = None,
-) -> float:
-    actual_loss = np.asarray(actual_loss, dtype=float).reshape(-1)
-    predicted_premium = np.asarray(predicted_premium, dtype=float).reshape(-1)
-    if weight is not None:
-        weight = np.asarray(weight, dtype=float).reshape(-1)
-        actual_loss = actual_loss * weight
-        predicted_premium = predicted_premium * weight
-    return _safe_div(float(np.sum(actual_loss)), float(np.sum(predicted_premium)), default=0.0)
-
-
-def classification_metrics(
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    threshold: float = 0.5,
-) -> Dict[str, float]:
-    y_true = np.asarray(y_true, dtype=float).reshape(-1)
-    y_pred = np.asarray(y_pred, dtype=float).reshape(-1)
-    pred_label = (y_pred >= threshold).astype(float)
-    acc = float(np.mean(pred_label == y_true))
-    precision = _safe_div(float(np.sum((pred_label == 1) & (y_true == 1))),
-                          float(np.sum(pred_label == 1)), default=0.0)
-    recall = _safe_div(float(np.sum((pred_label == 1) & (y_true == 1))),
-                       float(np.sum(y_true == 1)), default=0.0)
-    return {"accuracy": acc, "precision": precision, "recall": recall}
-
-
-def metrics_report(
-    y_true: np.ndarray,
-    y_pred: np.ndarray,
-    *,
-    task_type: str = "regression",
-    weight: Optional[np.ndarray] = None,
-) -> Dict[str, float]:
-    if task_type == "classification":
-        metrics = classification_metrics(y_true, y_pred)
-    else:
-        metrics = regression_metrics(y_true, y_pred, weight=weight)
-    return metrics
-
-
-def group_metrics(
-    df: pd.DataFrame,
-    *,
-    actual_col: str,
-    pred_col: str,
-    group_cols: Iterable[str],
-    weight_col: Optional[str] = None,
-) -> pd.DataFrame:
-    group_cols = list(group_cols)
-    work = df[group_cols].copy()
-    y_true = df[actual_col].to_numpy(dtype=float)
-    y_pred = df[pred_col].to_numpy(dtype=float)
-    err = y_true - y_pred
-    work["_y_true"] = y_true
-    work["_y_pred"] = y_pred
-    work["_err"] = err
-    work["_abs_err"] = np.abs(err)
-    work["_err_sq"] = err ** 2
-    work["_abs_ratio"] = work["_abs_err"] / np.clip(np.abs(work["_y_true"]), 1e-9, None)
-    work["_y_true_sq"] = work["_y_true"] ** 2
-
-    if weight_col:
-        w = df[weight_col].to_numpy(dtype=float)
-        work["_w"] = w
-        work["_w_err_sq"] = w * work["_err_sq"]
-        work["_w_abs_err"] = w * work["_abs_err"]
-
-    grouped = work.groupby(group_cols, dropna=False)
-    count = grouped["_y_true"].count().replace(0, 1.0)
-    sum_y = grouped["_y_true"].sum()
-    sum_y2 = grouped["_y_true_sq"].sum()
-    ss_tot = sum_y2 - (sum_y ** 2) / count
-    ss_tot = ss_tot.clip(lower=0.0)
-    ss_res = grouped["_err_sq"].sum()
-    r2 = 1.0 - (ss_res / ss_tot.replace(0.0, np.nan))
-    r2 = r2.fillna(0.0)
-
-    mape = grouped["_abs_ratio"].mean()
-    if weight_col:
-        sum_w = grouped["_w"].sum().replace(0, 1.0)
-        mse = grouped["_w_err_sq"].sum() / sum_w
-        mae = grouped["_w_abs_err"].sum() / sum_w
-    else:
-        mse = grouped["_err_sq"].sum() / count
-        mae = grouped["_abs_err"].sum() / count
-
-    rmse = np.sqrt(mse)
-    result = pd.DataFrame({
-        "rmse": rmse.astype(float),
-        "mae": mae.astype(float),
-        "mape": mape.astype(float),
-        "r2": r2.astype(float),
-    })
-    return result.reset_index()

ins_pricing_gemini/production/scoring.py

@@ -1,40 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Callable, Optional
-
-import numpy as np
-import pandas as pd
-
-
-def batch_score(
-    predict_fn: Callable[[pd.DataFrame], np.ndarray],
-    data: pd.DataFrame,
-    *,
-    output_col: str = "prediction",
-    batch_size: int = 10000,
-    output_path: Optional[str | Path] = None,
-    keep_input: bool = True,
-) -> pd.DataFrame:
-    """Batch scoring for large datasets."""
-    if batch_size <= 0:
-        raise ValueError("batch_size must be positive.")
-    n_rows = len(data)
-    prediction = np.empty(n_rows, dtype=float)
-    for start in range(0, n_rows, batch_size):
-        end = min(start + batch_size, n_rows)
-        chunk = data.iloc[start:end]
-        pred = np.asarray(predict_fn(chunk)).reshape(-1)
-        if pred.shape[0] != (end - start):
-            raise ValueError("predict_fn output length must match batch size.")
-        prediction[start:end] = pred
-    result = data.copy() if keep_input else pd.DataFrame(index=data.index)
-    result[output_col] = prediction
-    if output_path:
-        output_path = Path(output_path)
-        output_path.parent.mkdir(parents=True, exist_ok=True)
-        if output_path.suffix.lower() in {".parquet", ".pq"}:
-            result.to_parquet(output_path, index=False)
-        else:
-            result.to_csv(output_path, index=False)
-    return result

ins_pricing_gemini/reporting/__init__.py

@@ -1,11 +0,0 @@
-from __future__ import annotations
-
-from .report_builder import ReportPayload, build_report, write_report
-from .scheduler import schedule_daily
-
-__all__ = [
-    "ReportPayload",
-    "build_report",
-    "write_report",
-    "schedule_daily",
-]

ins_pricing_gemini/reporting/report_builder.py

@@ -1,72 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from datetime import datetime
-from pathlib import Path
-from typing import Dict, Optional
-
-import pandas as pd
-
-
-def _df_to_markdown(df: pd.DataFrame, max_rows: int = 20) -> str:
-    if df is None or df.empty:
-        return "_(no data)_"
-    data = df.copy()
-    if len(data) > max_rows:
-        data = data.head(max_rows)
-    headers = list(data.columns)
-    rows = data.astype(str).values.tolist()
-    lines = []
-    lines.append("| " + " | ".join(headers) + " |")
-    lines.append("| " + " | ".join(["---"] * len(headers)) + " |")
-    for row in rows:
-        lines.append("| " + " | ".join(row) + " |")
-    return "\n".join(lines)
-
-
-@dataclass
-class ReportPayload:
-    model_name: str
-    model_version: str
-    metrics: Dict[str, float]
-    risk_trend: Optional[pd.DataFrame] = None
-    drift_report: Optional[pd.DataFrame] = None
-    validation_table: Optional[pd.DataFrame] = None
-    extra_notes: Optional[str] = None
-
-
-def build_report(payload: ReportPayload) -> str:
-    now = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S UTC")
-    metrics_lines = [f"- {k}: {v:.6f}" for k, v in payload.metrics.items()]
-    metrics_block = "\n".join(metrics_lines) if metrics_lines else "_(no metrics)_"
-
-    report = [
-        f"# Model Report: {payload.model_name} ({payload.model_version})",
-        "",
-        f"Generated at: {now}",
-        "",
-        "## Model Validation",
-        metrics_block,
-    ]
-
-    if payload.validation_table is not None:
-        report.extend(["", "### Validation Details", _df_to_markdown(payload.validation_table)])
-
-    report.extend(["", "## Drift / Stability"])
-    report.append(_df_to_markdown(payload.drift_report))
-
-    report.extend(["", "## Risk Trend"])
-    report.append(_df_to_markdown(payload.risk_trend))
-
-    if payload.extra_notes:
-        report.extend(["", "## Notes", payload.extra_notes])
-
-    return "\n".join(report).strip() + "\n"
-
-
-def write_report(payload: ReportPayload, output_path: str | Path) -> Path:
-    output_path = Path(output_path)
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    content = build_report(payload)
-    output_path.write_text(content, encoding="utf-8")
-    return output_path

ins_pricing_gemini/reporting/scheduler.py

@@ -1,45 +0,0 @@
-from __future__ import annotations
-
-import threading
-import time
-from datetime import datetime, timedelta
-from typing import Callable, Optional
-
-
-def _next_run(run_time: str, now: Optional[datetime] = None) -> datetime:
-    if now is None:
-        now = datetime.now()
-    hour, minute = [int(x) for x in run_time.split(":")]
-    candidate = now.replace(hour=hour, minute=minute, second=0, microsecond=0)
-    if candidate <= now:
-        candidate = candidate + timedelta(days=1)
-    return candidate
-
-
-def schedule_daily(
-    job_fn: Callable[[], None],
-    *,
-    run_time: str = "01:00",
-    stop_event: Optional[threading.Event] = None,
-) -> threading.Thread:
-    """Run job_fn daily at local time HH:MM in a background thread."""
-    if stop_event is None:
-        stop_event = threading.Event()
-
-    def _loop():
-        while not stop_event.is_set():
-            next_time = _next_run(run_time)
-            sleep_seconds = (next_time - datetime.now()).total_seconds()
-            if sleep_seconds > 0:
-                stop_event.wait(timeout=sleep_seconds)
-            if stop_event.is_set():
-                break
-            try:
-                job_fn()
-            except Exception:
-                pass
-            time.sleep(1)
-
-    thread = threading.Thread(target=_loop, daemon=True)
-    thread.start()
-    return thread