leaklens-ml 0.4.0__tar.gz

leaklens_ml-0.4.0/LICENSE

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

leaklens_ml-0.4.0/PKG-INFO

@@ -0,0 +1,136 @@
+Metadata-Version: 2.4
+Name: leaklens-ml
+Version: 0.4.0
+Summary: Audit datasets and ML pipelines for data leakage
+Author: Eyad
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/eyadstein/leaklens
+Project-URL: Issues, https://github.com/eyadstein/leaklens/issues
+Keywords: data-leakage,machine-learning,mlops,data-science,scikit-learn,static-analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.3
+Provides-Extra: arena
+Requires-Dist: mlflow>=2.9; extra == "arena"
+Provides-Extra: app
+Requires-Dist: fastapi>=0.110; extra == "app"
+Requires-Dist: uvicorn>=0.27; extra == "app"
+Requires-Dist: python-multipart>=0.0.9; extra == "app"
+Requires-Dist: streamlit>=1.30; extra == "app"
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: mlflow>=2.9; extra == "dev"
+Requires-Dist: fastapi>=0.110; extra == "dev"
+Requires-Dist: httpx>=0.26; extra == "dev"
+Requires-Dist: python-multipart>=0.0.9; extra == "dev"
+Dynamic: license-file
+
+# LeakLens
+
+[![CI](https://github.com/eyadstein/leaklens/actions/workflows/ci.yml/badge.svg)](https://github.com/eyadstein/leaklens/actions/workflows/ci.yml)
+[![Leakage trust](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/eyadstein/leaklens/main/badge.json)](#trust-score-badge)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+**Catch data leakage before it fools you.** Most "99% accuracy" models are leaking. LeakLens audits both your **data** and your **code**, then proves what survives by training three model families on a leak-free pipeline.
+
+## What it catches
+| Where | Leak |
+|---|---|
+| Data | Target leakage (a single feature that almost perfectly predicts the label), ID-like columns, train/test row overlap, temporal leakage, entity/group overlap (`--group COL`) |
+| Code (`.py`, `.ipynb`) | Scaler/encoder/imputer fitted before the split, SMOTE before the split, transformers fitted on test/validation data |
+
+Every audit returns a 0-100 trust score. The CLI exits with code 1 on a high-severity leak, so it gates CI.
+
+## Demo
+
+$ leaklens demo.csv --target is_fraud --arena
+LeakLens trust score: 50/100
+[HIGH] target_leakage :: chargeback_flag :: alone predicts target (roc_auc=1.000)
+[MEDIUM] id_like :: txn_id :: 100.0% unique values; likely an identifier
+
+Arena ranked by pr_auc (auto-dropped: chargeback_flag, txn_id)
+model roc_auc pr_auc best_f1
+neural_net 0.8374 0.4219 0.4353
+linear 0.8410 0.4215 0.4304
+tree_ensemble 0.8242 0.3562 0.4103
+
+A leaked column makes accuracy look perfect. LeakLens drops it and shows the honest numbers.
+
+## Quick start
+
+pip install -e “.[dev,app]”
+leaklens train.csv --target label --test test.csv --time date
+leaklens --scan notebooks/
+leaklens train.csv --target label --test test.csv --group patient_id
+python examples/make_demo.py
+leaklens demo.csv --target is_fraud --arena
+mlflow ui --backend-store-uri sqlite:///mlflow.db
+
+
+## Model arena
+Auto-drops leaking and ID columns, then trains linear, gradient-boosted tree and neural-net models inside leak-safe pipelines (imputation, scaling and encoding are fitted on training data only). Runs are tracked in local MLflow (SQLite) and the winner is saved to `models/best.joblib`. Add `--time COL` for a temporal split.
+
+## API and UI
+
+uvicorn leaklens.api:app --port 8000 # docs at /docs
+streamlit run leaklens/ui.py
+
+Endpoints: `GET /health`, `POST /audit`, `POST /scan`, `POST /predict`.
+
+## Docker
+
+docker compose up --build
+
+API on http://localhost:8000/docs, UI on http://localhost:8501.
+
+## GitHub Action
+```yaml
+- uses: actions/checkout@v4
+- uses: eyadstein/leaklens@main
+  with:
+    path: notebooks
+```
+
+## Pre-commit hook
+```yaml
+repos:
+  - repo: https://github.com/eyadstein/leaklens
+    rev: main
+    hooks:
+      - id: leaklens
+```
+Blocks a commit when a notebook or script fits a transformer before the split.
+
+## Trust score badge
+
+leaklens --scan . --badge badge.json
+
+Commit `badge.json`, then point a shields.io endpoint badge at its raw URL (as at the top of this file).
+
+## Architecture
+```mermaid
+flowchart LR
+  A[CSV / notebooks] --> B[Data audit + leakage detectors]
+  A --> C[Static code scanner]
+  B --> D[Trust score]
+  C --> D
+  B --> E[Model arena + MLflow]
+  E --> F[best.joblib]
+  F --> G[FastAPI /predict]
+  D --> H[CLI / Streamlit / GitHub Action]
+```
+
+## Roadmap
+- [x] Core detectors, static scanner, model arena, API, UI
+- [x] Docker, GitHub Action, badge, CI
+- [x] Group/entity leakage detector
+- [x] PyPI packaging + release workflow (PyPI name `leaklens-ml`, command stays `leaklens`; create a GitHub release to publish)
+
+MIT licensed.

leaklens_ml-0.4.0/README.md

@@ -0,0 +1,102 @@
+# LeakLens
+
+[![CI](https://github.com/eyadstein/leaklens/actions/workflows/ci.yml/badge.svg)](https://github.com/eyadstein/leaklens/actions/workflows/ci.yml)
+[![Leakage trust](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/eyadstein/leaklens/main/badge.json)](#trust-score-badge)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+**Catch data leakage before it fools you.** Most "99% accuracy" models are leaking. LeakLens audits both your **data** and your **code**, then proves what survives by training three model families on a leak-free pipeline.
+
+## What it catches
+| Where | Leak |
+|---|---|
+| Data | Target leakage (a single feature that almost perfectly predicts the label), ID-like columns, train/test row overlap, temporal leakage, entity/group overlap (`--group COL`) |
+| Code (`.py`, `.ipynb`) | Scaler/encoder/imputer fitted before the split, SMOTE before the split, transformers fitted on test/validation data |
+
+Every audit returns a 0-100 trust score. The CLI exits with code 1 on a high-severity leak, so it gates CI.
+
+## Demo
+
+$ leaklens demo.csv --target is_fraud --arena
+LeakLens trust score: 50/100
+[HIGH] target_leakage :: chargeback_flag :: alone predicts target (roc_auc=1.000)
+[MEDIUM] id_like :: txn_id :: 100.0% unique values; likely an identifier
+
+Arena ranked by pr_auc (auto-dropped: chargeback_flag, txn_id)
+model roc_auc pr_auc best_f1
+neural_net 0.8374 0.4219 0.4353
+linear 0.8410 0.4215 0.4304
+tree_ensemble 0.8242 0.3562 0.4103
+
+A leaked column makes accuracy look perfect. LeakLens drops it and shows the honest numbers.
+
+## Quick start
+
+pip install -e “.[dev,app]”
+leaklens train.csv --target label --test test.csv --time date
+leaklens --scan notebooks/
+leaklens train.csv --target label --test test.csv --group patient_id
+python examples/make_demo.py
+leaklens demo.csv --target is_fraud --arena
+mlflow ui --backend-store-uri sqlite:///mlflow.db
+
+
+## Model arena
+Auto-drops leaking and ID columns, then trains linear, gradient-boosted tree and neural-net models inside leak-safe pipelines (imputation, scaling and encoding are fitted on training data only). Runs are tracked in local MLflow (SQLite) and the winner is saved to `models/best.joblib`. Add `--time COL` for a temporal split.
+
+## API and UI
+
+uvicorn leaklens.api:app --port 8000 # docs at /docs
+streamlit run leaklens/ui.py
+
+Endpoints: `GET /health`, `POST /audit`, `POST /scan`, `POST /predict`.
+
+## Docker
+
+docker compose up --build
+
+API on http://localhost:8000/docs, UI on http://localhost:8501.
+
+## GitHub Action
+```yaml
+- uses: actions/checkout@v4
+- uses: eyadstein/leaklens@main
+  with:
+    path: notebooks
+```
+
+## Pre-commit hook
+```yaml
+repos:
+  - repo: https://github.com/eyadstein/leaklens
+    rev: main
+    hooks:
+      - id: leaklens
+```
+Blocks a commit when a notebook or script fits a transformer before the split.
+
+## Trust score badge
+
+leaklens --scan . --badge badge.json
+
+Commit `badge.json`, then point a shields.io endpoint badge at its raw URL (as at the top of this file).
+
+## Architecture
+```mermaid
+flowchart LR
+  A[CSV / notebooks] --> B[Data audit + leakage detectors]
+  A --> C[Static code scanner]
+  B --> D[Trust score]
+  C --> D
+  B --> E[Model arena + MLflow]
+  E --> F[best.joblib]
+  F --> G[FastAPI /predict]
+  D --> H[CLI / Streamlit / GitHub Action]
+```
+
+## Roadmap
+- [x] Core detectors, static scanner, model arena, API, UI
+- [x] Docker, GitHub Action, badge, CI
+- [x] Group/entity leakage detector
+- [x] PyPI packaging + release workflow (PyPI name `leaklens-ml`, command stays `leaklens`; create a GitHub release to publish)
+
+MIT licensed.

leaklens_ml-0.4.0/leaklens/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0"

leaklens_ml-0.4.0/leaklens/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

leaklens_ml-0.4.0/leaklens/api.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import io
+from pathlib import Path
+
+import joblib
+import numpy as np
+import pandas as pd
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from pydantic import BaseModel
+
+from . import __version__
+from .audit import audit
+from .leakage import scan, score
+from .scanner import scan_source
+
+app = FastAPI(title="LeakLens", version=__version__)
+
+
+class ScanReq(BaseModel):
+    source: str
+    name: str = "snippet.py"
+
+
+class PredictReq(BaseModel):
+    rows: list[dict]
+    model_path: str = "models/best.joblib"
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok", "version": __version__}
+
+
+@app.post("/audit")
+async def audit_csv(file: UploadFile = File(...), target: str = Form(...), threshold: float = Form(0.95)):
+    try:
+        df = pd.read_csv(io.BytesIO(await file.read()))
+    except Exception as e:
+        raise HTTPException(400, f"bad CSV: {e}")
+    if target not in df.columns:
+        raise HTTPException(422, f"target '{target}' not in columns")
+    fs = scan(df, target, threshold)
+    return {"trust_score": score(fs), "audit": audit(df, target), "findings": [f.to_dict() for f in fs]}
+
+
+@app.post("/scan")
+def scan_code(req: ScanReq):
+    fs = scan_source(req.source, req.name)
+    return {"trust_score": score(fs), "findings": [f.to_dict() for f in fs]}
+
+
+@app.post("/predict")
+def predict(req: PredictReq):
+    p = Path(req.model_path)
+    if not p.exists():
+        raise HTTPException(404, "model not found; run: leaklens data.csv --target T --arena")
+    b = joblib.load(p)
+    df = pd.DataFrame(req.rows)
+    miss = [c for c in b["features"] if c not in df.columns]
+    if miss:
+        raise HTTPException(422, f"missing features: {miss}")
+    X = df[b["features"]].copy()
+    pipe = b["pipeline"]
+    tf = pipe.named_steps["prep"].transformers_
+    for c in tf[0][2]:
+        X[c] = pd.to_numeric(X[c], errors="coerce")
+    for c in tf[1][2]:
+        X[c] = X[c].astype(str)
+    if b["task"] == "classification":
+        out = []
+        for pr in pipe.predict_proba(X):
+            i = int(np.argmax(pr))
+            out.append({"label": b["classes"][i], "score": float(pr[1] if len(pr) == 2 else pr[i])})
+    else:
+        out = [{"value": float(v)} for v in pipe.predict(X)]
+    return {"model": b["model"], "task": b["task"], "predictions": out}

leaklens_ml-0.4.0/leaklens/arena.py

@@ -0,0 +1,140 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import joblib
+import mlflow
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.ensemble import HistGradientBoostingClassifier, HistGradientBoostingRegressor
+from sklearn.impute import SimpleImputer
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.metrics import (accuracy_score, average_precision_score, f1_score, mean_absolute_error,
+                             mean_squared_error, precision_recall_curve, precision_score, r2_score,
+                             recall_score, roc_auc_score)
+from sklearn.model_selection import train_test_split
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+
+from .leakage import scan
+
+
+def _models(clf, seed):
+    if clf:
+        return {
+            "linear": LogisticRegression(max_iter=1000, class_weight="balanced"),
+            "tree_ensemble": HistGradientBoostingClassifier(random_state=seed),
+            "neural_net": MLPClassifier(hidden_layer_sizes=(64, 32), max_iter=300, early_stopping=True, random_state=seed),
+        }
+    return {
+        "linear": Ridge(),
+        "tree_ensemble": HistGradientBoostingRegressor(random_state=seed),
+        "neural_net": MLPRegressor(hidden_layer_sizes=(64, 32), max_iter=300, early_stopping=True, random_state=seed),
+    }
+
+
+def _prep(num, cat):
+    return ColumnTransformer([
+        ("num", Pipeline([("imp", SimpleImputer(strategy="median")), ("sc", StandardScaler())]), num),
+        ("cat", OneHotEncoder(handle_unknown="infrequent_if_exist", max_categories=20, sparse_output=False), cat),
+    ])
+
+
+def _metrics(clf, y, pipe, X):
+    out = {}
+    pred = pipe.predict(X)
+    if clf:
+        proba = pipe.predict_proba(X)
+        if proba.shape[1] == 2:
+            s = proba[:, 1]
+            try:
+                out["roc_auc"] = roc_auc_score(y, s)
+                out["pr_auc"] = average_precision_score(y, s)
+                p, r, _ = precision_recall_curve(y, s)
+                out["best_f1"] = float((2 * p * r / np.maximum(p + r, 1e-12)).max())
+            except ValueError:
+                pass
+            out["f1"] = f1_score(y, pred, zero_division=0)
+            out["precision"] = precision_score(y, pred, zero_division=0)
+            out["recall"] = recall_score(y, pred, zero_division=0)
+        else:
+            out["f1_macro"] = f1_score(y, pred, average="macro", zero_division=0)
+            out["accuracy"] = accuracy_score(y, pred)
+    else:
+        out["mae"] = mean_absolute_error(y, pred)
+        out["rmse"] = float(np.sqrt(mean_squared_error(y, pred)))
+        out["r2"] = r2_score(y, pred)
+    return {k: float(v) for k, v in out.items()}
+
+
+def run(df, target, time_col=None, out_dir="models", tracking_uri="sqlite:///mlflow.db",
+        experiment="leaklens-arena", drop_leaks=True, seed=0):
+    d = df[df[target].notna()].copy()
+    if len(d) < 50:
+        raise ValueError("need at least 50 labeled rows")
+    dropped = []
+    if drop_leaks:
+        dropped = [f.column for f in scan(d, target)
+                   if f.kind == "id_like" or (f.kind == "target_leakage" and f.severity == "high")]
+    y_raw = d[target]
+    clf = y_raw.dtype.kind not in "iuf" or y_raw.nunique() <= 20
+    if clf:
+        cats = y_raw.astype("category")
+        y = cats.cat.codes.to_numpy()
+        classes = [str(c) for c in cats.cat.categories]
+    else:
+        y = y_raw.astype(float).to_numpy()
+        classes = []
+    drop = {target, *dropped}
+    if time_col:
+        drop.add(time_col)
+    X = d.drop(columns=[c for c in drop if c in d.columns])
+    X = X.drop(columns=X.select_dtypes(include=["datetime", "datetimetz"]).columns)
+    for c in X.select_dtypes("bool").columns:
+        X[c] = X[c].astype(int)
+    num = X.select_dtypes(include=["number"]).columns.tolist()
+    cat = [c for c in X.columns if c not in num]
+    if num:
+        X[num] = X[num].replace([np.inf, -np.inf], np.nan)
+    for c in cat:
+        X[c] = X[c].astype(str)
+    n = len(d)
+    if time_col:
+        t = pd.to_datetime(d[time_col], errors="coerce").to_numpy()
+        order = np.argsort(t, kind="stable")
+        cut = int(n * 0.8)
+        tr_i, te_i = order[:cut], order[cut:]
+    else:
+        strat = y if clf and np.bincount(y).min() >= 2 else None
+        tr_i, te_i = train_test_split(np.arange(n), test_size=0.2, stratify=strat, random_state=seed)
+    if clf and len(np.unique(y[tr_i])) < 2:
+        raise ValueError("training split has a single class")
+    Xtr, Xte, ytr, yte = X.iloc[tr_i], X.iloc[te_i], y[tr_i], y[te_i]
+    primary = ("pr_auc" if len(classes) == 2 else "f1_macro") if clf else "rmse"
+    mlflow.set_tracking_uri(tracking_uri)
+    mlflow.set_experiment(experiment)
+    rows, pipes = [], {}
+    for name, model in _models(clf, seed).items():
+        pipe = Pipeline([("prep", _prep(num, cat)), ("model", model)])
+        with mlflow.start_run(run_name=name):
+            mlflow.log_params({"model": name, "task": "classification" if clf else "regression",
+                               "split": "temporal" if time_col else "random", "n_train": len(tr_i),
+                               "n_test": len(te_i), "dropped": ",".join(map(str, dropped)) or "none"})
+            pipe.fit(Xtr, ytr)
+            m = _metrics(clf, yte, pipe, Xte)
+            mlflow.log_metrics({k: v for k, v in m.items() if np.isfinite(v)})
+        pipes[name] = pipe
+        rows.append({"model": name, **m})
+    res = pd.DataFrame(rows)
+    if primary not in res:
+        res[primary] = np.nan
+    res = res.sort_values(primary, ascending=(primary == "rmse"), na_position="last").reset_index(drop=True)
+    Path(out_dir).mkdir(parents=True, exist_ok=True)
+    joblib.dump({"pipeline": pipes[res.loc[0, "model"]], "features": list(X.columns), "target": target,
+                 "task": "classification" if clf else "regression", "classes": classes,
+                 "dropped": dropped, "model": res.loc[0, "model"]}, Path(out_dir) / "best.joblib")
+    res.attrs["dropped"] = dropped
+    res.attrs["primary"] = primary
+    return res

leaklens_ml-0.4.0/leaklens/audit.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import pandas as pd
+
+
+def audit(df: pd.DataFrame, target: str | None = None) -> dict:
+    out = {
+        "rows": int(len(df)),
+        "cols": int(df.shape[1]),
+        "duplicate_rows": int(df.duplicated().sum()),
+        "null_rate": {c: round(float(v), 4) for c, v in df.isna().mean().items() if v > 0},
+        "cardinality": {c: int(df[c].nunique(dropna=True)) for c in df.columns},
+    }
+    if target is not None and target in df.columns:
+        vc = df[target].value_counts(normalize=True)
+        out["target_distribution"] = {str(k): round(float(v), 4) for k, v in vc.items()}
+        out["minority_rate"] = round(float(vc.min()), 6)
+    return out

leaklens_ml-0.4.0/leaklens/cli.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import argparse
+import json
+
+import pandas as pd
+
+from .audit import audit
+from .leakage import group_overlap, group_risk, scan, score, split_overlap, temporal_overlap
+from .scanner import scan_path
+
+
+def main(argv=None) -> int:
+    p = argparse.ArgumentParser(prog="leaklens", description="Audit datasets and ML code for leakage")
+    p.add_argument("train", nargs="?")
+    p.add_argument("--target")
+    p.add_argument("--test")
+    p.add_argument("--time")
+    p.add_argument("--group", help="entity column (patient, customer...) to check for group leakage")
+    p.add_argument("--threshold", type=float, default=0.95)
+    p.add_argument("--scan", nargs="+", help="file or folder of .py/.ipynb to scan for pipeline leaks")
+    p.add_argument("--arena", action="store_true", help="compare 3 model families, tracked in MLflow")
+    p.add_argument("--out", default="models")
+    p.add_argument("--tracking-uri", default="sqlite:///mlflow.db")
+    p.add_argument("--json", action="store_true")
+    p.add_argument("--badge", help="write a shields.io endpoint JSON with the trust score")
+    a = p.parse_args(argv)
+    if not a.train and not a.scan:
+        p.error("give a CSV and/or --scan PATH")
+    if a.train and not a.target:
+        p.error("--target is required with a CSV")
+    if a.arena and not a.train:
+        p.error("--arena needs a CSV")
+    fs, rep, res = [], {}, None
+    if a.train:
+        tr = pd.read_csv(a.train)
+        fs += scan(tr, a.target, a.threshold)
+        if a.test:
+            te = pd.read_csv(a.test)
+            fs += split_overlap(tr, te)
+            if a.time:
+                fs += temporal_overlap(tr, te, a.time)
+        if a.group:
+            fs += group_risk(tr, a.group)
+            if a.test:
+                fs += group_overlap(tr, te, a.group)
+        rep["audit"] = audit(tr, a.target)
+        if a.arena:
+            try:
+                from .arena import run
+            except ImportError:
+                p.error('install extras: pip install -e ".[arena]"')
+            res = run(tr, a.target, a.time, a.out, a.tracking_uri)
+            rep["arena"] = res.round(4).to_dict("records")
+    if a.scan:
+        for s in a.scan:
+            fs += scan_path(s)
+    rep = {"trust_score": score(fs), **rep, "findings": [f.to_dict() for f in fs]}
+    if a.badge:
+        s = rep["trust_score"]
+        col = "brightgreen" if s >= 85 else "yellow" if s >= 60 else "red"
+        with open(a.badge, "w", encoding="utf-8") as fh:
+            json.dump({"schemaVersion": 1, "label": "leakage trust", "message": f"{s}/100", "color": col}, fh)
+    if a.json:
+        print(json.dumps(rep, indent=2))
+    else:
+        print(f"LeakLens trust score: {rep['trust_score']}/100")
+        for f in fs:
+            print(f"[{f.severity.upper()}] {f.kind} :: {f.column} :: {f.detail}")
+        if not fs:
+            print("No leakage found.")
+        if res is not None:
+            print(f"\nArena ranked by {res.attrs['primary']} (auto-dropped: {', '.join(map(str, res.attrs['dropped'])) or 'none'})")
+            print(res.round(4).to_string(index=False))
+    return 1 if any(f.severity == "high" for f in fs) else 0