closed-loop-default-detection 0.1.0__tar.gz

closed_loop_default_detection-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,184 @@
+# 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/pyproject.toml

@@ -0,0 +1,84 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "closed-loop-default-detection"
+version = "0.1.0"
+description = "CLUE-style closed loop that measures selective-labels default detection on synthetic SMB lending cohorts and finds the PD model's operating frontier."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Hossain Pazooki", email = "hossain@pazooki.com" }]
+keywords = [
+    "selective-labels",
+    "probability-of-default",
+    "reject-inference",
+    "causal-inference",
+    "calibration",
+    "synthetic-data",
+    "off-policy-evaluation",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: Financial and Insurance Industry",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+    "Typing :: Typed",
+]
+# Library dependencies are declared as ranges so the package installs alongside
+# a practitioner's own stack. The EXACT provenance pins under which the committed
+# artifacts and the frozen byte-identity baseline were captured
+# (scikit-learn 1.9.0 / numpy 2.4.6, Python 3.14.2) live in requirements-dev.txt
+# and are exercised by the CI `pinned-repro` job. HistGradientBoosting float
+# output shifts across scikit-learn releases, so a handful of float-exact tests
+# (marked `pinned`) are reproducible only under those pins.
+dependencies = [
+    "numpy>=2.0",
+    "pandas>=2.2",
+    "scikit-learn>=1.6",
+    "scipy>=1.11",
+    "matplotlib>=3.8",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0", "pytest-cov>=5"]
+docs = ["sphinx>=7", "furo", "myst-parser>=2"]
+
+[project.urls]
+Homepage = "https://github.com/hossainpazooki/closed-loop-default-detection"
+Repository = "https://github.com/hossainpazooki/closed-loop-default-detection"
+Issues = "https://github.com/hossainpazooki/closed-loop-default-detection/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+# Ship the PEP 561 typing marker so downstream type-checkers honor cldd's hints.
+[tool.setuptools.package-data]
+cldd = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-q"
+markers = [
+    "pinned: asserts exact or tight floating-point output of the calibrated PD model; reproducible only under the pinned scikit-learn/numpy in requirements-dev.txt. The CI compat matrix deselects these with `-m 'not pinned'`.",
+]
+
+# Coverage is opt-in (run `pytest --cov=cldd`); it is not wired into addopts so a
+# plain `pytest` stays lightweight. The private-data fidelity path (cldd/fidelity.py)
+# is only exercised when the real dataset is present, so its data-loading branch is
+# expected to be uncovered on public CI by design — see README.
+[tool.coverage.run]
+source = ["cldd"]
+branch = true
+
+[tool.coverage.report]
+show_missing = true
+exclude_also = [
+    "if TYPE_CHECKING:",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+]

closed_loop_default_detection-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

closed_loop_default_detection-0.1.0/src/cldd/__init__.py

@@ -0,0 +1,96 @@
+"""Closed-loop default-rate detection — a CLUE-style harness for selective labels.
+
+generate (``synthetic``) -> measure (``eval_default``) -> improve/frontier
+(``loop``). See README.md for the CLUE mapping and how to run.
+"""
+
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:  # pyproject `version` is the single source of truth (read from installed metadata)
+    __version__ = _pkg_version("closed-loop-default-detection")
+except PackageNotFoundError:  # running from a source tree with no install
+    __version__ = "0.1.0"
+
+from .correctors import (
+    CorrectionOutcome,
+    Corrector,
+    CorrectorContext,
+    DisjointRetrainCorrector,
+    ExplorationCorrector,
+    IPWReweightCorrector,
+    NaiveCorrector,
+)
+from .counterfactual import (
+    CounterfactualResult,
+    GComputationEstimator,
+    generate_queries,
+    run_counterfactual_eval,
+)
+from .diagnostics import PositivityDiagnostics, positivity_diagnostics
+from .reject_inference import (
+    AugmentationCorrector,
+    FuzzyAugmentationCorrector,
+    ParcellingCorrector,
+    ReclassificationCorrector,
+    RejectInferenceCorrector,
+)
+from .eval_default import PdDetectionResult, fit_observed_model, score_pd_detection
+from .model_pd import CalibratedPDClassifier, CalibratedPDModel
+from .feedback import FeedbackLoop, FeedbackResult, GenerationResult
+from .loop import LeverMetrics, LoopResult, RoundResult, SelectiveLabelsLoop
+from .scm import (
+    BANK_FEED_COLUMNS,
+    FEATURE_COLUMNS,
+    INTERVENABLE_FEATURES,
+    InterventionResult,
+    SCMState,
+    StructuralBorrowerGenerator,
+    dag_children,
+    dag_parents,
+)
+from .synthetic import SyntheticBorrowerGenerator
+
+__all__ = [
+    "__version__",
+    "SyntheticBorrowerGenerator",
+    "StructuralBorrowerGenerator",
+    "SCMState",
+    "InterventionResult",
+    "INTERVENABLE_FEATURES",
+    "FEATURE_COLUMNS",
+    "BANK_FEED_COLUMNS",
+    "dag_children",
+    "dag_parents",
+    "SelectiveLabelsLoop",
+    "LoopResult",
+    "RoundResult",
+    "LeverMetrics",
+    "Corrector",
+    "CorrectorContext",
+    "CorrectionOutcome",
+    "NaiveCorrector",
+    "IPWReweightCorrector",
+    "DisjointRetrainCorrector",
+    "ExplorationCorrector",
+    "RejectInferenceCorrector",
+    "ReclassificationCorrector",
+    "AugmentationCorrector",
+    "FuzzyAugmentationCorrector",
+    "ParcellingCorrector",
+    "FeedbackLoop",
+    "FeedbackResult",
+    "GenerationResult",
+    "PositivityDiagnostics",
+    "positivity_diagnostics",
+    "PdDetectionResult",
+    "fit_observed_model",
+    "score_pd_detection",
+    "CalibratedPDModel",
+    "CalibratedPDClassifier",
+    "CounterfactualResult",
+    "GComputationEstimator",
+    "run_counterfactual_eval",
+    "generate_queries",
+]