honestml 1.0.0__tar.gz

honestml-1.0.0/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+build/
+dist/
+.eggs/
+
+# Tooling caches
+.ruff_cache/
+.mypy_cache/
+.pytest_cache/
+.hypothesis/
+.import_linter_cache/
+
+# Docs build
+site/
+# docs/automl-productionization/
+
+# Environments
+.venv/
+venv/
+.env
+
+# IDE / OS
+.idea/
+.vscode/
+.DS_Store
+.CLAUDE/
+
+# local working files, not for publication
+_legacy/
+catboost_info/
+benchmarks/results.json
+benchmarks/native_cat_gate_results.json
+
+# showcase notebook inputs/outputs (large Kaggle datasets, generated submissions)
+notebooks/data/
+notebooks/results/
+notebooks/.ipynb_checkpoints/
+
+# internal design/architecture packages (kept local, not published)
+docs/architecture/
+docs/audit/
+docs/implementation/

honestml-1.0.0/CHANGELOG.md

@@ -0,0 +1,79 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows
+[Keep a Changelog](https://keepachangelog.com/) and the project adheres to
+[Semantic Versioning](https://semver.org/) (see `docs/versioning-policy.md`).
+
+## [Unreleased]
+
+## [1.0.0] - 2026-06-24
+
+First public release: a tabular AutoML library for binary/multiclass classification and
+regression, built around honest model selection — the score you see is the score you can
+expect in production.
+
+The honesty-benchmark baseline (`benchmarks/baseline.json`) is bootstrapped for this release;
+subsequent releases gate against it for no regress (see `docs/releasing.md`).
+
+### Added
+- **Task and data input contract:** sklearn-compatible `AutoML` facade
+  (`fit`/`predict`/`predict_proba`/`score`, works in `Pipeline`) over pandas/polars/numpy
+  inputs, with typed schema inference, stable train↔inference categorical encoding,
+  boundary validation, and row metadata via `fit(..., sample_weight=, groups=, time=,
+  label_time=)`.
+- **CV schemes:** stratified / kfold / group / holdout / timeseries (purge+embargo, value-based
+  time ordering) / timeseries_period (calendar or Δt periods with wall-clock purge/embargo,
+  optional per-period weighting and a rolling max-train window) (`CVConfig(scheme=...)`; `"auto"`
+  picks the task default); every fold passes an anti-leakage validation.
+- **Honest selection:** out-of-fold scoring on a shared CV split with a seeded
+  paired-bootstrap **equivalence band** (`significance="bootstrap"`, default) — the
+  simplest model statistically indistinguishable from the best wins and ties are
+  disclosed, never hidden; opt-in probability calibration (`CVConfig(calibrate=...)`)
+  gated by cross-fitted improvement.
+- **Outer holdout + finalize:** `CVConfig(outer_holdout=...)` carves a scheme-aware,
+  untouched holdout scored exactly once for an unbiased final estimate; `finalize=True`
+  then refits the shipped model on all data after scoring.
+- **Presets:** `AutoML(preset="fast" | "balanced" | "best")` — declarative partial configs
+  that fill only unset parameters; an explicit argument always wins, and honesty settings
+  are not presettable.
+- **Budget + resume/cache:** `budget=<seconds>` or `BudgetConfig(...)` (time / trial /
+  memory limits) with graceful degradation to the best model so far; `cache="dir/"`
+  reuses per-candidate results keyed by a deterministic run fingerprint and resumes
+  interrupted runs.
+- **Feature engineering + selection:** opt-in `FEConfig` (leakage-controlled out-of-fold
+  target encoding, frequency encoding, datetime deltas, categorical intersections) and
+  `FeatureSelectionConfig` (importance / random-probe / null-importance / sequential /
+  SHAP strategies with honest multi-strategy arbitration on a holdout or nested CV). The
+  `sequential` wrapper chooses its feature count honestly: it explores the full backward
+  trajectory and the **fewest features statistically indistinguishable from the best**
+  (significance band + Occam tie-break, default `significance="bootstrap"`) win, instead of
+  the raw out-of-fold argmax; `significance="off"` reproduces the plain argmax. The band is
+  scored on the selection folds and is strictly more conservative than argmax (residual
+  optimism documented; independent-OOF scoring is a future improvement).
+- **Hyperparameter optimization:** `hpo=HPOConfig(...)` — seeded Optuna search over
+  per-model spaces on an inner CV of the dev data; tuned candidates then compete in the
+  regular honest selection, sharing the run's time budget.
+- **Ensembling:** `ensemble=EnsembleConfig(...)` — greedy (Caruana) or weighted blend over
+  the out-of-fold predictions, shipped only if significantly better than the best single
+  model; the gate decision is always reported.
+- **Run report + rendering:** versioned, tracker-independent JSON `run_report_` with full
+  provenance (resolved config, run fingerprint, leaderboard, equivalence band, timings,
+  budget/FS/HPO/ensemble outcomes); `save_run_report` plus `render_report` to markdown or
+  self-contained HTML (charts via the `report` extra).
+- **Experiment tracking:** opt-in `tracker="mlflow"` / `TrackerConfig(...)` logs the run
+  report after fit — fail-soft and free of global MLflow state; custom backends plug in
+  via the `ExperimentTracker` port.
+- **Artifacts + serving:** `save_artifact` / `load_artifact` — a self-contained, versioned
+  artifact directory with a sha256 integrity manifest; native boosting bodies
+  (`model_format="native"`, no pickle); the slim `honestml[inference]` extra serves
+  `load_artifact(...).predict(...)` without importing the training stack.
+- **ONNX export:** `export_onnx(model, directory, sample=...)` — a parity-gated,
+  export-only bundle (linear and boosting models) for external runtimes.
+- **Models and plugins:** lightweight built-in zoo (baseline, linear) plus
+  catboost/lightgbm/xgboost via the `boosting` extra; third-party estimators via
+  `honestml.models` entry points (see `docs/plugin-contract.md`), discovered lazily with
+  fail-fast name-conflict detection.
+- **Logging, exceptions, typing:** silent-by-default `honestml` logger (`NullHandler`);
+  one exception taxonomy rooted at `AutoMLError`; fully typed (`py.typed`);
+  `import honestml` stays lightweight — optional extras load lazily and a missing one
+  fails fast with the exact `pip install honestml[...]` hint.

honestml-1.0.0/LICENSE

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

honestml-1.0.0/PKG-INFO

@@ -0,0 +1,190 @@
+Metadata-Version: 2.4
+Name: honestml
+Version: 1.0.0
+Summary: General tabular AutoML library (classification + regression), production-grade.
+Project-URL: Homepage, https://github.com/sukhov-is/HonestML
+Project-URL: Documentation, https://sukhov-is.github.io/HonestML/
+Project-URL: Repository, https://github.com/sukhov-is/HonestML
+Author: honestml contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: automl,boosting,feature-selection,honestml,machine-learning,tabular
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: polars>=1.0
+Requires-Dist: pydantic>=2
+Requires-Dist: scikit-learn>=1.3
+Provides-Extra: all
+Requires-Dist: catboost>=1.2; extra == 'all'
+Requires-Dist: lightgbm>=4.0; extra == 'all'
+Requires-Dist: matplotlib>=3.7; extra == 'all'
+Requires-Dist: mlflow>=2.9; extra == 'all'
+Requires-Dist: onnx>=1.21; extra == 'all'
+Requires-Dist: onnxmltools>=1.16; extra == 'all'
+Requires-Dist: onnxruntime>=1.23; extra == 'all'
+Requires-Dist: optuna>=3.4; extra == 'all'
+Requires-Dist: psutil>=5.9; extra == 'all'
+Requires-Dist: pyarrow>=14.0; extra == 'all'
+Requires-Dist: shap>=0.44; extra == 'all'
+Requires-Dist: skl2onnx>=1.20; extra == 'all'
+Requires-Dist: xgboost>=2.0; extra == 'all'
+Provides-Extra: boosting
+Requires-Dist: catboost>=1.2; extra == 'boosting'
+Requires-Dist: lightgbm>=4.0; extra == 'boosting'
+Requires-Dist: xgboost>=2.0; extra == 'boosting'
+Provides-Extra: catboost
+Requires-Dist: catboost>=1.2; extra == 'catboost'
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.90; extra == 'dev'
+Requires-Dist: import-linter>=2.0; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5; extra == 'dev'
+Requires-Dist: mkdocstrings[python]>=0.27; extra == 'dev'
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: optuna>=3.4; extra == 'dev'
+Requires-Dist: pre-commit>=3.5; extra == 'dev'
+Requires-Dist: pytest>=7.4; extra == 'dev'
+Requires-Dist: pyyaml>=6; extra == 'dev'
+Requires-Dist: ruff==0.15.16; extra == 'dev'
+Provides-Extra: inference
+Requires-Dist: joblib>=1.3; extra == 'inference'
+Requires-Dist: numpy>=1.24; extra == 'inference'
+Requires-Dist: pandas>=2.0; extra == 'inference'
+Requires-Dist: polars>=1.0; extra == 'inference'
+Requires-Dist: pydantic>=2; extra == 'inference'
+Requires-Dist: scikit-learn>=1.3; extra == 'inference'
+Provides-Extra: lightgbm
+Requires-Dist: lightgbm>=4.0; extra == 'lightgbm'
+Provides-Extra: memory
+Requires-Dist: psutil>=5.9; extra == 'memory'
+Provides-Extra: mlflow
+Requires-Dist: mlflow>=2.9; extra == 'mlflow'
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.21; extra == 'onnx'
+Requires-Dist: onnxmltools>=1.16; extra == 'onnx'
+Requires-Dist: onnxruntime>=1.23; extra == 'onnx'
+Requires-Dist: skl2onnx>=1.20; extra == 'onnx'
+Provides-Extra: optuna
+Requires-Dist: optuna>=3.4; extra == 'optuna'
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow>=14.0; extra == 'pyarrow'
+Provides-Extra: report
+Requires-Dist: matplotlib>=3.7; extra == 'report'
+Provides-Extra: shap
+Requires-Dist: shap>=0.44; extra == 'shap'
+Provides-Extra: xgboost
+Requires-Dist: xgboost>=2.0; extra == 'xgboost'
+Description-Content-Type: text/markdown
+
+# honestml
+
+[![PyPI](https://img.shields.io/pypi/v/honestml.svg)](https://pypi.org/project/honestml/)
+[![CI](https://github.com/sukhov-is/HonestML/actions/workflows/ci.yml/badge.svg)](https://github.com/sukhov-is/HonestML/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://pypi.org/project/honestml/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Tabular AutoML where the leaderboard doesn't lie.** Most AutoML frameworks ship the
+model with the best validation score — but that number is optimistic, because you
+selected for it. honestml is built so that the score you see is the score you can
+expect in production.
+
+It covers binary / multiclass classification and regression behind a clean, extensible
+core. The honesty is in *how it selects*: out-of-fold scoring on a shared CV split; a
+bootstrap **equivalence band** that, among the statistically indistinguishable best
+candidates, ships the simplest one; leakage-controlled feature engineering and
+selection; an optional untouched outer holdout scored exactly once; and reproducible,
+fingerprinted runs.
+
+```python
+from honestml import AutoML
+
+model = AutoML(task="binary").fit(X, y)
+proba = model.predict_proba(X_new)
+print(model.best_model_id_, model.leaderboard_)
+```
+
+The library is silent by default (a `NullHandler` on the `honestml` logger); enable
+progress with `logging.getLogger("honestml").setLevel(logging.INFO)` plus
+`logging.basicConfig()`.
+
+## Install
+
+```bash
+pip install honestml                 # lightweight core (baseline/linear models)
+pip install "honestml[boosting]"     # core + catboost, lightgbm, xgboost
+pip install "honestml[all]"          # boosting + optuna (HPO), mlflow (tracking), onnx, shap, report and the rest
+pip install "honestml[inference]"    # slim serving runtime (load_artifact + predict only)
+```
+
+Requires Python >= 3.10. Heavy dependencies are optional extras and imported
+lazily — `import honestml` stays light, and a missing extra fails fast with the
+exact `pip install honestml[...]` hint.
+
+## What you get
+
+| Capability | How |
+|---|---|
+| Honest model selection | OOF scoring on a shared CV split; a seeded bootstrap **equivalence band** (`significance="bootstrap"`, the default) collects candidates statistically indistinguishable from the best, and the simplest member of the band wins — ties are disclosed, not hidden |
+| CV schemes | stratified / kfold / group / holdout / **timeseries** (purge+embargo, value-based time order) / **timeseries_period** (calendar or Δt period folds, wall-clock gaps, optional per-period weighting, rolling train window) — `fit(..., time=, label_time=, groups=)` |
+| Outer holdout + finalize | `cv=CVConfig(outer_holdout=0.2)`: selection sees only DEV, the holdout is scored once; the shipped model is refit on all data after scoring (`finalize=True`) |
+| Presets | `AutoML(preset="fast" / "balanced" / "best")` — declarative, data-driven partial configs; an explicit argument always wins; honesty parameters are not presettable |
+| Budget + resume | `budget=600` (seconds) or `BudgetConfig(...)` with graceful degradation; `cache="runs/"` resumes by run fingerprint |
+| Feature engineering / selection | OOF-honest target (binary-only) / frequency encoding, datetime deltas, intersections; importance / null-importance / random-probe / sequential / SHAP selection with honest arbitration |
+| HPO + ensembling | `hpo=HPOConfig(...)` (Optuna, per-model search before the honest selection); `ensemble=EnsembleConfig()` — a Caruana/weighted blend ships **only if significantly better** |
+| Run report | `model.run_report_` (versioned JSON, tracker-independent); `save_run_report` and `render_report` produce markdown or self-contained HTML (charts via the `report` extra) |
+| Experiment tracking | `tracker="mlflow"` or `TrackerConfig(...)` — post-fit, fail-soft, no global mlflow state; custom backends via the `ExperimentTracker` port |
+| Artifacts + serving | `save_artifact` / `load_artifact` — versioned, integrity-checked artifact directory (see Standalone inference below) |
+| ONNX export | `honestml.export_onnx(model, dir, sample=...)` — parity-gated, export-only bundle for external runtimes |
+| Plugins | third-party models via `honestml.models` entry points (`docs/plugin-contract.md`) |
+
+## Standalone inference
+
+```python
+from honestml import load_artifact
+
+model = load_artifact("artifact_dir/")   # integrity-checked against the sha256 manifest
+predictions = model.predict(X_new)
+```
+
+The artifact directory is self-contained — manifest, preprocessing schema and the
+model body — and loads under the slim `honestml[inference]` install: no training
+stack is imported. Boosting models can be saved with structural native bodies
+(`model_format="native"`). **Trust model:** the default body is joblib/pickle —
+load only artifacts you trust; native bodies contain no pickle (a non-boosting
+estimator and the optional calibrator still ship as joblib).
+
+## Reproducibility
+
+Every run computes a **fingerprint** over the resolved config, data signature,
+estimator set and library versions; the run report carries it together with the
+full provenance (leaderboard, band, budget outcome, FS/HPO/ensemble decisions,
+timings). Same inputs → same selection.
+
+## Documentation
+
+Documentation lives in `docs/` — quickstart, API reference, correctness guide and
+the plugin contract; build it locally with `mkdocs serve`. Source and issue
+tracker: <https://github.com/sukhov-is/HonestML>.
+
+## Development
+
+```bash
+uv sync --extra dev --extra boosting --extra shap --extra pyarrow --extra mlflow
+uv run pytest                 # full suite (onnx export tests also need `--extra onnx`, Python >=3.11)
+uv run ruff check src tests; uv run mypy src/honestml; uv run lint-imports
+```
+
+The layered architecture (core ← adapters ← application ← composition) is enforced
+by import-linter. See `docs/releasing.md` for the release pipeline and
+`benchmarks/` for the honesty benchmark suite.
+
+## License
+
+MIT (see `LICENSE`).

honestml-1.0.0/README.md

@@ -0,0 +1,105 @@
+# honestml
+
+[![PyPI](https://img.shields.io/pypi/v/honestml.svg)](https://pypi.org/project/honestml/)
+[![CI](https://github.com/sukhov-is/HonestML/actions/workflows/ci.yml/badge.svg)](https://github.com/sukhov-is/HonestML/actions/workflows/ci.yml)
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://pypi.org/project/honestml/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+**Tabular AutoML where the leaderboard doesn't lie.** Most AutoML frameworks ship the
+model with the best validation score — but that number is optimistic, because you
+selected for it. honestml is built so that the score you see is the score you can
+expect in production.
+
+It covers binary / multiclass classification and regression behind a clean, extensible
+core. The honesty is in *how it selects*: out-of-fold scoring on a shared CV split; a
+bootstrap **equivalence band** that, among the statistically indistinguishable best
+candidates, ships the simplest one; leakage-controlled feature engineering and
+selection; an optional untouched outer holdout scored exactly once; and reproducible,
+fingerprinted runs.
+
+```python
+from honestml import AutoML
+
+model = AutoML(task="binary").fit(X, y)
+proba = model.predict_proba(X_new)
+print(model.best_model_id_, model.leaderboard_)
+```
+
+The library is silent by default (a `NullHandler` on the `honestml` logger); enable
+progress with `logging.getLogger("honestml").setLevel(logging.INFO)` plus
+`logging.basicConfig()`.
+
+## Install
+
+```bash
+pip install honestml                 # lightweight core (baseline/linear models)
+pip install "honestml[boosting]"     # core + catboost, lightgbm, xgboost
+pip install "honestml[all]"          # boosting + optuna (HPO), mlflow (tracking), onnx, shap, report and the rest
+pip install "honestml[inference]"    # slim serving runtime (load_artifact + predict only)
+```
+
+Requires Python >= 3.10. Heavy dependencies are optional extras and imported
+lazily — `import honestml` stays light, and a missing extra fails fast with the
+exact `pip install honestml[...]` hint.
+
+## What you get
+
+| Capability | How |
+|---|---|
+| Honest model selection | OOF scoring on a shared CV split; a seeded bootstrap **equivalence band** (`significance="bootstrap"`, the default) collects candidates statistically indistinguishable from the best, and the simplest member of the band wins — ties are disclosed, not hidden |
+| CV schemes | stratified / kfold / group / holdout / **timeseries** (purge+embargo, value-based time order) / **timeseries_period** (calendar or Δt period folds, wall-clock gaps, optional per-period weighting, rolling train window) — `fit(..., time=, label_time=, groups=)` |
+| Outer holdout + finalize | `cv=CVConfig(outer_holdout=0.2)`: selection sees only DEV, the holdout is scored once; the shipped model is refit on all data after scoring (`finalize=True`) |
+| Presets | `AutoML(preset="fast" / "balanced" / "best")` — declarative, data-driven partial configs; an explicit argument always wins; honesty parameters are not presettable |
+| Budget + resume | `budget=600` (seconds) or `BudgetConfig(...)` with graceful degradation; `cache="runs/"` resumes by run fingerprint |
+| Feature engineering / selection | OOF-honest target (binary-only) / frequency encoding, datetime deltas, intersections; importance / null-importance / random-probe / sequential / SHAP selection with honest arbitration |
+| HPO + ensembling | `hpo=HPOConfig(...)` (Optuna, per-model search before the honest selection); `ensemble=EnsembleConfig()` — a Caruana/weighted blend ships **only if significantly better** |
+| Run report | `model.run_report_` (versioned JSON, tracker-independent); `save_run_report` and `render_report` produce markdown or self-contained HTML (charts via the `report` extra) |
+| Experiment tracking | `tracker="mlflow"` or `TrackerConfig(...)` — post-fit, fail-soft, no global mlflow state; custom backends via the `ExperimentTracker` port |
+| Artifacts + serving | `save_artifact` / `load_artifact` — versioned, integrity-checked artifact directory (see Standalone inference below) |
+| ONNX export | `honestml.export_onnx(model, dir, sample=...)` — parity-gated, export-only bundle for external runtimes |
+| Plugins | third-party models via `honestml.models` entry points (`docs/plugin-contract.md`) |
+
+## Standalone inference
+
+```python
+from honestml import load_artifact
+
+model = load_artifact("artifact_dir/")   # integrity-checked against the sha256 manifest
+predictions = model.predict(X_new)
+```
+
+The artifact directory is self-contained — manifest, preprocessing schema and the
+model body — and loads under the slim `honestml[inference]` install: no training
+stack is imported. Boosting models can be saved with structural native bodies
+(`model_format="native"`). **Trust model:** the default body is joblib/pickle —
+load only artifacts you trust; native bodies contain no pickle (a non-boosting
+estimator and the optional calibrator still ship as joblib).
+
+## Reproducibility
+
+Every run computes a **fingerprint** over the resolved config, data signature,
+estimator set and library versions; the run report carries it together with the
+full provenance (leaderboard, band, budget outcome, FS/HPO/ensemble decisions,
+timings). Same inputs → same selection.
+
+## Documentation
+
+Documentation lives in `docs/` — quickstart, API reference, correctness guide and
+the plugin contract; build it locally with `mkdocs serve`. Source and issue
+tracker: <https://github.com/sukhov-is/HonestML>.
+
+## Development
+
+```bash
+uv sync --extra dev --extra boosting --extra shap --extra pyarrow --extra mlflow
+uv run pytest                 # full suite (onnx export tests also need `--extra onnx`, Python >=3.11)
+uv run ruff check src tests; uv run mypy src/honestml; uv run lint-imports
+```
+
+The layered architecture (core ← adapters ← application ← composition) is enforced
+by import-linter. See `docs/releasing.md` for the release pipeline and
+`benchmarks/` for the honesty benchmark suite.
+
+## License
+
+MIT (see `LICENSE`).

honestml-1.0.0/pyproject.toml

@@ -0,0 +1,145 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "honestml"
+version = "1.0.0"
+description = "General tabular AutoML library (classification + regression), production-grade."
+readme = "README.md"
+requires-python = ">=3.10"
+# PEP 639 (ADR-0077 §1): SPDX expression + the license file shipped in the dist
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "honestml contributors" }]
+keywords = ["honestml", "automl", "machine-learning", "tabular", "boosting", "feature-selection"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+
+# Lightweight core: only what is needed to import `honestml` and the domain ports.
+dependencies = [
+    "numpy>=1.24",
+    "pandas>=2.0",
+    "polars>=1.0",
+    "scikit-learn>=1.3",
+    "pydantic>=2",
+]
+
+[project.optional-dependencies]
+catboost = ["catboost>=1.2"]
+lightgbm = ["lightgbm>=4.0"]
+xgboost = ["xgboost>=2.0"]
+boosting = ["catboost>=1.2", "lightgbm>=4.0", "xgboost>=2.0"]
+# Slim serving runtime: load a ModelArtifact and predict without the training stack (ADR-0066 §3).
+# pandas is REQUIRED — the Reader inference path imports it. Slim-ness vs [all] comes from NOT installing
+# the training-only extras (optuna/shap/mlflow/onnx) plus the lazy import cone never executing them; the
+# set mirrors core + an explicit joblib (a boosting artifact additionally needs its own extra).
+inference = ["numpy>=1.24", "pandas>=2.0", "polars>=1.0", "scikit-learn>=1.3", "pydantic>=2", "joblib>=1.3"]
+shap = ["shap>=0.44"]
+optuna = ["optuna>=3.4"]
+mlflow = ["mlflow>=2.9"]
+# floors validated against the locked boosting zoo (onnx 1.21 / onnxruntime 1.23 /
+# skl2onnx 1.20 / onnxmltools 1.16); onnxruntime powers the export-time
+# parity gate (ADR-0071 §3/§6) and the external consumer.
+onnx = ["onnx>=1.21", "onnxruntime>=1.23", "onnxmltools>=1.16", "skl2onnx>=1.20"]
+report = ["matplotlib>=3.7"]
+# psutil powers the cross-platform RSS probe for memory_limit_mb (ADR-0039); imported lazily in
+# RunBudget only when a memory limit is set, never at top-level import.
+memory = ["psutil>=5.9"]
+# pyarrow accelerates native pandas materialization in string-heavy adapters
+# (ADR-0005); the numpy+codes path does not require it.
+pyarrow = ["pyarrow>=14.0"]
+all = [
+    "catboost>=1.2", "lightgbm>=4.0", "xgboost>=2.0", "shap>=0.44",
+    "optuna>=3.4", "mlflow>=2.9", "onnx>=1.21", "onnxruntime>=1.23",
+    "onnxmltools>=1.16", "skl2onnx>=1.20", "matplotlib>=3.7", "pyarrow>=14.0", "psutil>=5.9",
+]
+dev = [
+    "ruff==0.15.16",
+    "mypy>=1.8",
+    "import-linter>=2.0",
+    "pytest>=7.4",
+    "hypothesis>=6.90",
+    "pre-commit>=3.5",
+    "mkdocs-material>=9.5",
+    # API reference is generated from docstrings (ADR-0077 §4) — prose would drift
+    "mkdocstrings[python]>=0.27",
+    # the release-engineering yaml-parse tests — explicit, not transitive
+    "pyyaml>=6",
+    # optuna powers the HPO adapter (ADR-0061); in dev so the suite exercises the HPO path
+    "optuna>=3.4",
+]
+
+[project.urls]
+Homepage = "https://github.com/sukhov-is/HonestML"
+Documentation = "https://sukhov-is.github.io/HonestML/"
+Repository = "https://github.com/sukhov-is/HonestML"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/honestml"]
+
+# Ship only the package + release metadata in the sdist; keep tests/docs/notebooks/benchmarks out
+# of the published tarball (the wheel already ships only `src/honestml`).
+[tool.hatch.build.targets.sdist]
+# leading-slash anchors to the repo root (gitignore semantics) so a bare README.md/CHANGELOG.md
+# inside docs/tests/notebooks is not pulled in recursively.
+include = ["src/honestml", "/README.md", "/CHANGELOG.md", "/LICENSE", "/pyproject.toml"]
+
+# ---------------------------------------------------------------------------
+# Ruff (lint + format)
+# ---------------------------------------------------------------------------
+[tool.ruff]
+line-length = 100
+target-version = "py310"
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "T20"]
+# T20 (flake8-print): no `print` in library code (ADR-0003).
+# E501 is left to the formatter (do not fail on legacy long lines during migration).
+ignore = ["E501"]
+
+[tool.ruff.lint.per-file-ignores]
+"tests/**" = ["T20"]
+"docs/**" = ["T20", "E", "F"]
+# showcase notebooks print their results by design (like tests); F/E/I rules still apply.
+"notebooks/**" = ["T20"]
+
+# ---------------------------------------------------------------------------
+# Mypy — strict on the domain core, lenient elsewhere (ADR-0004)
+# ---------------------------------------------------------------------------
+[tool.mypy]
+# 3.12: numpy>=2.5 ships stubs using PEP 695 `type` statements that mypy parses only under a
+# 3.12 target; runtime 3.10 support is enforced by the test matrix + ruff (UP, target py310).
+python_version = "3.12"
+warn_unused_configs = true
+ignore_missing_imports = true
+warn_redundant_casts = true
+
+[[tool.mypy.overrides]]
+module = "honestml.core.*"
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+no_implicit_optional = true
+warn_return_any = true
+strict_equality = true
+
+# ---------------------------------------------------------------------------
+# Pytest
+# ---------------------------------------------------------------------------
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+markers = [
+    "unit: fast pure-core tests (default)",
+    "property: hypothesis property tests (leakage/monotonicity invariants)",
+    "golden: determinism of metrics on synthetic data with fixed seed",
+    "slow: full pipeline run on synthetic data",
+]