closed-loop-default-detection 0.1.0__py3-none-any.whl

cldd/synthetic.py

@@ -0,0 +1,256 @@
+"""Synthetic SMB applicant cohort generator with planted default ground truth.
+
+This is the **generate** stage of the closed loop and the analog of
+``upstream-label-correction/core/synthetic.py``. Where that planted molecular
+mislabels, this plants a true ``default_flag`` for *every* applicant and then
+hides the labels through a prior-underwriter approval policy — exactly the
+**selective-labels** structure of the Intuit SMB challenge.
+
+Two ground-truth facts are planted and known only to the harness:
+
+1. ``true_default`` — sampled for **all** applicants from a latent risk model
+   that is a known function of the observed features *plus a small unobserved
+   confounder*. This is the truth a real lender never sees for the declines.
+2. ``approved`` — the prior policy funds the lowest-risk ``approval_rate``
+   fraction by a *selection score*. ``selection_severity`` controls how tightly
+   that score tracks true risk:
+
+   * ``severity = 0`` — approval is independent of true risk (selection at
+     random; declines and approvals share the same default distribution).
+   * ``severity = 1`` — approval tracks the full latent risk, *including the
+     unobserved confounder*, so the declined pool is the high-risk tail and part
+     of the selection is invisible to any observed-feature propensity model.
+
+Severity is the corruption axis the loop escalates to find the model's operating
+frontier — "selection regimes real data cannot probe". All randomness flows
+through one seeded ``numpy.random.Generator`` for byte-identical reproducibility.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+
+from . import config
+
+#: Observed feature columns exposed to the PD model. A realistic subset of the
+#: challenge's 44-column schema — enough to be credible, not exhaustive. Bank-feed
+#: columns are NaN when the applicant did not link a feed (structural missingness
+#: is itself signal).
+FEATURE_COLUMNS = [
+    "stated_annual_revenue",
+    "requested_amount",
+    "vintage_years",
+    "aggregate_credit_utilization",
+    "existing_debt_obligations",
+    "recent_inquiries_count_6mo",
+    "prior_loans_count",
+    "prior_loans_default_count",
+    "has_linked_bank_feed",
+    "observed_monthly_revenue_avg_3mo",  # bank-feed gated
+    "observed_overdraft_count_3mo",      # bank-feed gated
+    "payroll_regularity_score",          # bank-feed gated
+]
+
+#: Columns that are null exactly when ``has_linked_bank_feed`` is False.
+BANK_FEED_COLUMNS = [
+    "observed_monthly_revenue_avg_3mo",
+    "observed_overdraft_count_3mo",
+    "payroll_regularity_score",
+]
+
+
+def _zscore(x: np.ndarray) -> np.ndarray:
+    """NaN-aware standardization; missing entries contribute 0 to the latent risk."""
+    x = np.asarray(x, dtype=float)
+    mean = np.nanmean(x)
+    std = np.nanstd(x)
+    if not np.isfinite(std) or std == 0:
+        std = 1.0
+    z = (x - mean) / std
+    return np.nan_to_num(z, nan=0.0)
+
+
+class SyntheticBorrowerGenerator:
+    """Generate a synthetic SMB applicant cohort with planted default ground truth."""
+
+    def __init__(
+        self,
+        n_applicants: int = config.DEFAULT_N_APPLICANTS,
+        selection_severity: float = 0.0,
+        approval_rate: float = config.DEFAULT_APPROVAL_RATE,
+        target_base_rate: float = config.TARGET_BASE_DEFAULT_RATE,
+        bank_feed_rate: float = 0.64,
+        unobserved_strength: float = 0.7,
+        seed: int = config.RANDOM_SEED,
+    ) -> None:
+        if not 0.0 <= selection_severity <= 1.0:
+            raise ValueError(f"selection_severity must be in [0, 1]; got {selection_severity}")
+        if not 0.0 < approval_rate < 1.0:
+            raise ValueError(f"approval_rate must be in (0, 1); got {approval_rate}")
+        self.n_applicants = n_applicants
+        self.selection_severity = selection_severity
+        self.approval_rate = approval_rate
+        self.target_base_rate = target_base_rate
+        self.bank_feed_rate = bank_feed_rate
+        self.unobserved_strength = unobserved_strength
+        self.seed = seed
+        self.rng = np.random.Generator(np.random.PCG64(seed))
+
+    # ------------------------------------------------------------------ #
+    # Presets (mirror upstream's unit/benchmark)
+    # ------------------------------------------------------------------ #
+
+    @classmethod
+    def unit(cls, seed: int = config.RANDOM_SEED, **kwargs) -> "SyntheticBorrowerGenerator":
+        return cls(n_applicants=1500, seed=seed, **kwargs)
+
+    @classmethod
+    def benchmark(cls, seed: int = config.RANDOM_SEED, **kwargs) -> "SyntheticBorrowerGenerator":
+        return cls(n_applicants=8000, seed=seed, **kwargs)
+
+    # ------------------------------------------------------------------ #
+    # Public API
+    # ------------------------------------------------------------------ #
+
+    def generate_cohort(self) -> dict:
+        """Return one cohort dict with features + planted ground truth.
+
+        Keys
+        ----
+        features : pd.DataFrame
+            Observed model matrix (``FEATURE_COLUMNS``), NaN for unlinked feeds.
+        true_default : np.ndarray[int]
+            Planted default outcome for **all** applicants (the hidden truth).
+        approved : np.ndarray[bool]
+            Prior-policy funding mask; outcomes are observable only here.
+        prior_score : np.ndarray[float]
+            The selection score (lower = safer = funded first).
+        ground_truth : dict
+            severity / base_rate / approval_rate / seed / n_applicants.
+        """
+        features = self._draw_features()
+        latent_risk = self._latent_risk(features)  # includes unobserved confounder
+        true_default = (self.rng.random(self.n_applicants) < _sigmoid(latent_risk)).astype(int)
+        approved, prior_score = self._apply_selection(latent_risk)
+
+        return {
+            "features": features,
+            "true_default": true_default,
+            "approved": approved,
+            "prior_score": prior_score,
+            "ground_truth": {
+                "selection_severity": self.selection_severity,
+                "base_rate": float(true_default.mean()),
+                "approval_rate": float(approved.mean()),
+                "seed": self.seed,
+                "n_applicants": self.n_applicants,
+            },
+        }
+
+    # ------------------------------------------------------------------ #
+    # Internals
+    # ------------------------------------------------------------------ #
+
+    def _draw_features(self) -> pd.DataFrame:
+        rng = self.rng
+        n = self.n_applicants
+
+        stated_annual_revenue = rng.lognormal(mean=12.4, sigma=0.7, size=n)        # ~$240k median
+        requested_amount = np.clip(rng.lognormal(mean=9.7, sigma=0.55, size=n), 5_000, 50_000)
+        vintage_years = rng.gamma(shape=2.0, scale=2.5, size=n)
+        aggregate_credit_utilization = np.clip(rng.beta(2.0, 3.0, size=n), 0.0, 1.0)
+        existing_debt_obligations = rng.lognormal(mean=10.5, sigma=0.9, size=n)
+        recent_inquiries_count_6mo = rng.poisson(lam=1.8, size=n)
+        prior_loans_count = rng.poisson(lam=1.2, size=n)
+        # Defaults among prior loans rise with utilization (latent link to risk).
+        prior_default_p = np.clip(0.10 + 0.25 * aggregate_credit_utilization, 0.0, 1.0)
+        prior_loans_default_count = rng.binomial(np.maximum(prior_loans_count, 0), prior_default_p)
+
+        has_feed = rng.random(n) < self.bank_feed_rate
+        observed_monthly_revenue_avg_3mo = stated_annual_revenue / 12.0 * rng.lognormal(0.0, 0.15, size=n)
+        observed_overdraft_count_3mo = rng.poisson(lam=0.8, size=n).astype(float)
+        payroll_regularity_score = np.clip(rng.beta(5.0, 2.0, size=n), 0.0, 1.0)
+
+        df = pd.DataFrame(
+            {
+                "stated_annual_revenue": stated_annual_revenue,
+                "requested_amount": requested_amount,
+                "vintage_years": vintage_years,
+                "aggregate_credit_utilization": aggregate_credit_utilization,
+                "existing_debt_obligations": existing_debt_obligations,
+                "recent_inquiries_count_6mo": recent_inquiries_count_6mo.astype(float),
+                "prior_loans_count": prior_loans_count.astype(float),
+                "prior_loans_default_count": prior_loans_default_count.astype(float),
+                "has_linked_bank_feed": has_feed.astype(float),
+                "observed_monthly_revenue_avg_3mo": observed_monthly_revenue_avg_3mo,
+                "observed_overdraft_count_3mo": observed_overdraft_count_3mo,
+                "payroll_regularity_score": payroll_regularity_score,
+            },
+            columns=FEATURE_COLUMNS,
+        )
+
+        # Structural missingness: bank-feed signals are null without a linked feed.
+        df.loc[~has_feed, BANK_FEED_COLUMNS] = np.nan
+        return df
+
+    def _latent_risk(self, df: pd.DataFrame) -> np.ndarray:
+        """Known logistic risk function over observed features + an unobserved confounder."""
+        debt_to_revenue = df["existing_debt_obligations"].to_numpy() / np.maximum(
+            df["stated_annual_revenue"].to_numpy(), 1.0
+        )
+        prior_default_rate = df["prior_loans_default_count"].to_numpy() / (
+            df["prior_loans_count"].to_numpy() + 1.0
+        )
+        has_feed = df["has_linked_bank_feed"].to_numpy() > 0.5
+
+        # Unobserved confounder: drives true risk AND (at high severity) selection,
+        # but is never exposed to the PD model — this is what bounds the frontier.
+        u = self.rng.standard_normal(self.n_applicants)
+
+        logit = (
+            +0.60 * _zscore(df["aggregate_credit_utilization"].to_numpy())
+            + 0.50 * _zscore(debt_to_revenue)
+            + 0.40 * _zscore(df["recent_inquiries_count_6mo"].to_numpy())
+            + 0.40 * _zscore(df["observed_overdraft_count_3mo"].to_numpy())
+            + 0.50 * _zscore(prior_default_rate)
+            - 0.40 * _zscore(df["payroll_regularity_score"].to_numpy())
+            - 0.30 * _zscore(np.log(df["stated_annual_revenue"].to_numpy()))
+            - 0.30 * _zscore(df["vintage_years"].to_numpy())
+            + 0.20 * (~has_feed).astype(float)  # no feed => slightly riskier (signal)
+            + self.unobserved_strength * u
+        )
+        # Shift the intercept so the planted base rate lands near the target.
+        logit += _solve_intercept(logit, self.target_base_rate)
+        return logit
+
+    def _apply_selection(self, latent_risk: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+        """Fund the lowest-risk ``approval_rate`` fraction by a severity-blended score.
+
+        ``prior_score`` blends standardized true latent risk with independent
+        noise: at severity 0 it is pure noise (random selection), at severity 1 it
+        is the full latent risk (tightest selection, partly on the unobservable).
+        """
+        sev = self.selection_severity
+        noise = self.rng.standard_normal(self.n_applicants)
+        prior_score = sev * _zscore(latent_risk) + (1.0 - sev) * noise  # lower == safer
+        cutoff = np.quantile(prior_score, self.approval_rate)
+        approved = prior_score <= cutoff
+        return approved, prior_score
+
+
+def _sigmoid(x: np.ndarray) -> np.ndarray:
+    return 1.0 / (1.0 + np.exp(-x))
+
+
+def _solve_intercept(logit_no_intercept: np.ndarray, target_rate: float) -> float:
+    """Bisection for the intercept ``c`` s.t. ``mean(sigmoid(logit + c)) == target``."""
+    lo, hi = -10.0, 10.0
+    for _ in range(60):
+        mid = 0.5 * (lo + hi)
+        rate = float(np.mean(_sigmoid(logit_no_intercept + mid)))
+        if rate < target_rate:
+            lo = mid
+        else:
+            hi = mid
+    return 0.5 * (lo + hi)

closed_loop_default_detection-0.1.0.dist-info/METADATA

@@ -0,0 +1,218 @@
+Metadata-Version: 2.4
+Name: closed-loop-default-detection
+Version: 0.1.0
+Summary: CLUE-style closed loop that measures selective-labels default detection on synthetic SMB lending cohorts and finds the PD model's operating frontier.
+Author-email: Hossain Pazooki <hossain@pazooki.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/hossainpazooki/closed-loop-default-detection
+Project-URL: Repository, https://github.com/hossainpazooki/closed-loop-default-detection
+Project-URL: Issues, https://github.com/hossainpazooki/closed-loop-default-detection/issues
+Keywords: selective-labels,probability-of-default,reject-inference,causal-inference,calibration,synthetic-data,off-policy-evaluation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=2.0
+Requires-Dist: pandas>=2.2
+Requires-Dist: scikit-learn>=1.6
+Requires-Dist: scipy>=1.11
+Requires-Dist: matplotlib>=3.8
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: myst-parser>=2; extra == "docs"
+Dynamic: license-file
+
+# CLDD — closed-loop default detection
+
+[![CI](https://github.com/hossainpazooki/closed-loop-default-detection/actions/workflows/ci.yml/badge.svg)](https://github.com/hossainpazooki/closed-loop-default-detection/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+[![Docs: Sphinx](https://img.shields.io/badge/docs-sphinx-blue.svg)](docs/)
+[![Python ≥3.10](https://img.shields.io/badge/python-%E2%89%A53.10-blue.svg)](pyproject.toml)
+
+**Stress-test a probability-of-default (PD) model under *selective labels* — and get the
+severity at which it breaks.** Real lending data only labels the loans a prior underwriter
+approved, so you cannot measure calibration on the applicants you *declined* — exactly where a
+new model must still be right. CLDD builds synthetic lending worlds with planted ground truth,
+hides labels the way real approval policies do, and grades every correction against that truth.
+
+- **Deterministic** — byte-identical per seed, scikit-learn-only, no services or GPUs.
+- **Pluggable** — correction levers (IPW, retrain, exploration, reject inference) are classes;
+  add yours by subclassing `Corrector`.
+- **Honest by construction** — every number below recomputes from committed CSVs; limits are
+  reported, not smoothed over.
+
+## The result it produces
+
+The loop escalates selection severity until correction fails and reports the **operating
+frontier** — the last severity at which declined-cohort calibration still holds (target
+ECE ≤ 0.10). From the committed runs (`artifacts/clue_frontier*.csv`, seed 42):
+
+| Selection severity | 0.0 | 0.2 | 0.4 | 0.6 |
+|---|---|---|---|---|
+| Naive declined ECE (flat world) | 0.021 | 0.045 | 0.108 | 0.161 |
+| **IPW-corrected** (flat world) | 0.020 | 0.038 | **0.086 ✓** | **0.154 ✗** |
+| **IPW-corrected** (SCM world) | 0.036 | 0.038 | **0.097 ✓** | **0.244 ✗** |
+
+Both worlds land the frontier at **severity 0.4**, and the counterfactual deliverable breaks at
+the same boundary: across 25 seeds, g-computation cuts strong-propagation counterfactual MAE
+from 0.099 to 0.086 (−13.5%, positive on 24/25 seeds, Wilcoxon p = 1.5e-7) *inside* the
+frontier — and collapses to a negligible +0.0017 at full severity, where **no deployable
+advantage is claimed**. One cause explains both: selection through an **unobserved
+confounder**, which backdoor adjustment and IPW cannot fix. That single measured limit — not
+an unverifiable score — is the deliverable.
+
+Reproduce the headline from committed evidence: `python scripts/paired_significance.py`.
+The full independent assessment (methodology, all numbers, what didn't hold) is the
+accompanying article, [`FABLE.md`](FABLE.md).
+
+## Install
+
+```bash
+pip install closed-loop-default-detection
+```
+
+The import name is **`cldd`**. For development (tests, docs, the committed evidence),
+install from source:
+
+```bash
+git clone https://github.com/hossainpazooki/closed-loop-default-detection.git
+cd closed-loop-default-detection
+pip install -e ".[dev]"
+```
+
+Python ≥ 3.10; dependencies are ranges (`numpy>=2.0`, `pandas>=2.2`, `scikit-learn>=1.6`,
+`scipy>=1.11`, `matplotlib>=3.8`) so `cldd` sits alongside your stack. Exact pins for
+float-exact reproduction: [`requirements-dev.txt`](requirements-dev.txt)
+([details](docs/validation.md)).
+
+## 60-second tour
+
+```python
+from cldd import SelectiveLabelsLoop
+
+result = SelectiveLabelsLoop(improve_mode="both").run()   # "reweight" | "retrain" | "both"
+print("Operating frontier:", result.frontier_severity)
+for r in result.rounds:
+    print(r.selection_severity, r.naive.declined_ece, r.passed)
+```
+
+```mermaid
+flowchart TD
+    A["<b>1. Generate</b><br/>synthetic cohort at a given selection severity<br/>plant true default, then hide it via the approval policy"]
+    B["<b>2. Measure</b><br/>train the PD model on approved rows only,<br/>score it against planted truth on the declined subpopulation"]
+    C["<b>3. Improve</b><br/>apply a correction lever:<br/>IPW reweight &middot; disjoint retrain &middot; exploration"]
+    D{"Corrected declined-cohort<br/>ECE &le; target?"}
+    E["<b>Operating frontier</b><br/>report the highest severity<br/>that still passes"]
+
+    A --> B --> C --> D
+    D -->|"yes &mdash; raise the severity"| A
+    D -->|"no &mdash; stop"| E
+```
+
+A runnable end-to-end demo (classic + custom-lever paths) is
+[`examples/quickstart.py`](examples/quickstart.py). Full mechanics, diagnostics, and the
+feedback simulation: [docs/how-it-works.md](docs/how-it-works.md).
+
+> **Scope.** CLDD is a synthetic **validation harness**, not a production pipeline: retraining
+> and feedback are seeded simulations inside the harness; it never acts on live data or real
+> lending decisions.
+
+## What's in the box
+
+Everything is importable from top-level `cldd` (full reference: the [Sphinx docs](docs/)):
+
+| Import | What it is |
+|---|---|
+| `SelectiveLabelsLoop` | the closed loop; `.run()` → `LoopResult` (frontier + per-round metrics) |
+| `Corrector` + `NaiveCorrector`, `IPWReweightCorrector`, `DisjointRetrainCorrector`, `ExplorationCorrector` | the lever ABC and the four built-ins |
+| `ReclassificationCorrector`, `AugmentationCorrector`, `FuzzyAugmentationCorrector`, `ParcellingCorrector` | four classic reject-inference methods, graded against planted truth ([honest results](docs/reject_inference.md)) |
+| `SyntheticBorrowerGenerator`, `StructuralBorrowerGenerator` | the flat and fitted-SCM synthetic worlds |
+| `run_counterfactual_eval`, `GComputationEstimator` | counterfactual validator (g-computation vs naive conditioning) |
+| `FeedbackLoop` | model-in-the-loop selective-labels simulation |
+| `positivity_diagnostics` | observable regime/drift alarm — needs **no** declined-row labels |
+| `CalibratedPDClassifier` | the calibrated PD detector as a scikit-learn estimator |
+| `cldd.fidelity.run_fidelity_gate` | SCM-vs-real **marginal**-fidelity gate (univariate marginals only) |
+
+**Add a lever** by subclassing `Corrector` (`name`, `control_priority`, `apply`) and passing
+`correctors=[NaiveCorrector(), MyCorrector()]` — the legacy `improve_mode` API is unchanged
+and byte-identical. Contract details: [CONTRIBUTING.md](CONTRIBUTING.md).
+
+**Use the detector from sklearn tooling** — `CalibratedPDClassifier` is a thin, tested wrapper
+(binary-only; NaN features OK; the full `check_estimator` battery passes with zero failed
+checks on scikit-learn 1.7.2–1.9.0; probabilities byte-identical to the research API):
+
+```python
+from sklearn.model_selection import cross_val_score
+from cldd import CalibratedPDClassifier
+
+scores = cross_val_score(CalibratedPDClassifier(random_state=42), X, y, scoring="neg_brier_score")
+```
+
+## Command-line drivers
+
+Each driver runs without install (adds `src/` to the path) and writes to `artifacts/`:
+
+```bash
+python scripts/run_clue.py                    # the closed loop → frontier table + plot (--generator scm for the SCM world)
+python scripts/run_seed_sweep.py --quick      # counterfactual certification (drop --quick for all seeds)
+python scripts/run_reject_inference.py        # reject-inference levers vs the frontier
+python scripts/run_exploration_sweep.py       # frontier vs exploration budget
+python scripts/run_feedback.py                # model-in-the-loop feedback simulation
+python scripts/paired_significance.py         # recompute the headline stat from committed CSVs
+```
+
+## Validation
+
+`pytest` — 123 tests, all synthetic, no real data needed. CI runs a pinned-repro job (exact
+pins), a cross-version/OS compat matrix, and a strict docs build. Six float-sensitive tests
+reproduce only under the pins in `requirements-dev.txt`; the optional marginal-fidelity gate
+compares the SCM against a **private** real dataset via `CLDD_DATA_DIR` and is the only thing
+that needs it. Details, reproducibility, and troubleshooting:
+[docs/validation.md](docs/validation.md).
+
+## Documentation
+
+| Where | What |
+|---|---|
+| [docs/quickstart.md](docs/quickstart.md) | run the loop, the counterfactual eval, the fidelity report |
+| [docs/how-it-works.md](docs/how-it-works.md) | loop mechanics, diagnostics, feedback simulation, repo map |
+| [docs/configuration.md](docs/configuration.md) | every knob (`config.py`) and the one env var |
+| [docs/validation.md](docs/validation.md) | tests, gates, reproducibility, troubleshooting |
+| [docs/reject_inference.md](docs/reject_inference.md) | the four RI methods and their honest (modest) results |
+| [`FABLE.md`](FABLE.md) | **the accompanying article** — independent results & methodology assessment |
+
+Build locally: `pip install -e ".[docs]" && sphinx-build -b html -W docs docs/_build/html`.
+
+## Status
+
+`0.1.0` **alpha** on [PyPI](https://pypi.org/project/closed-loop-default-detection/),
+changelog in [CHANGELOG.md](CHANGELOG.md). Shipped: the loop, both worlds, all levers, the
+fidelity gate, the sklearn estimator, CI on three gates. CLDD began as a validation harness
+for the Intuit TechWeek SMB Underwriting Challenge; it is not a submission and does not
+alter challenge files.
+
+## Citation
+
+Metadata in [`CITATION.cff`](CITATION.cff) (GitHub's "Cite this repository" reads it):
+
+```bibtex
+@software{pazooki_cldd_2026,
+  author  = {Pazooki, Hossain},
+  title   = {{closed-loop-default-detection}: measuring selective-labels default
+             detection and the PD model's operating frontier},
+  year    = {2026},
+  version = {0.1.0},
+  license = {MIT},
+  url     = {https://github.com/hossainpazooki/closed-loop-default-detection}
+}
+```

closed_loop_default_detection-0.1.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+cldd/__init__.py,sha256=BvY-xpcoGzWKfUs7tpgSYciqT44KpxXp6JlpfemQE6g,2761
+cldd/config.py,sha256=H9wbxMlz7SospB3Q9qZhkTwTWcQzEs_Bm2whyTkDFIw,4632
+cldd/correctors.py,sha256=QpJWK64X8ibDe-dBqD0S2EGcqQKvztKzx4M2nfx_hB4,6075
+cldd/counterfactual.py,sha256=eoseTCms2M01EAheNLJ2KcQS_TnpQZivuvyNOnKfGuE,33364
+cldd/diagnostics.py,sha256=7tvJS8E96FUJemdl18ttiIY2LdwBqd3LJXMAMwITF9M,4448
+cldd/eval_default.py,sha256=SZIPJ8a4rGdHZRiY_oqoLUO9WOv09ty1f2a7BfWnBIY,6294
+cldd/feedback.py,sha256=kTRI2UxRQFlIjwVJEgx2yAxeXd084ClKB8rq2Euz5O8,8253
+cldd/fidelity.py,sha256=oEh2jJGT0Fq-_IZjvEBLwfRtRogmgdvC-xTXeFxpjCQ,16810
+cldd/loop.py,sha256=OO0SOplUSeoK56WN8YlML7Rdzu3XPrFL26NYijzpz_s,17168
+cldd/model_pd.py,sha256=etYU8fy2Lmb_nmGIRP5NmxTNbnuFv8FVWNPeSlI5UPE,8551
+cldd/py.typed,sha256=Vuiuf2j9sxEv9xZUVTk0Bx0nmCWPTxTb5KWXBPDNAZ0,54
+cldd/reject_inference.py,sha256=GeBuiUro8KVngAkdYlsE0L9z4fIAc0jHSFVmuCVOPvo,12535
+cldd/scm.py,sha256=QeMBLQZJpmhGtJ07itLjGExDOgsNT7JzGpva0ojpAbk,50397
+cldd/synthetic.py,sha256=F2wv34yX5y2Shj6Bw97bd6IFemLB_KMTBlp7zUSmyEU,11672
+closed_loop_default_detection-0.1.0.dist-info/licenses/LICENSE,sha256=B3dinmRNljbrbsZv4qToUNiWR-NTzPZ4temLVVSvA8U,1072
+closed_loop_default_detection-0.1.0.dist-info/METADATA,sha256=rKfsfsrqDGb8DgvMtOQfaUeTDQR0Ds6V9v45GCj9dmQ,11089
+closed_loop_default_detection-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+closed_loop_default_detection-0.1.0.dist-info/top_level.txt,sha256=vsEjy8OVY3hmsf5R_aO7IY9z-k5BowRPd4lSx3Mf4Qs,5
+closed_loop_default_detection-0.1.0.dist-info/RECORD,,

closed_loop_default_detection-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

closed_loop_default_detection-0.1.0.dist-info/licenses/LICENSE

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

closed_loop_default_detection-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+cldd