millwright 0.1.0__tar.gz

millwright-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,168 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+# One in-flight run per ref; a new push cancels the previous.
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  CARGO_TERM_COLOR: always
+  # Every job builds against the committed Cargo.lock. `--locked` turns a stale
+  # or drifted lockfile into a hard error — the reproducibility guarantee that
+  # pairs with the exact-version engine pins in Cargo.toml.
+  CARGO_NET_RETRY: "3"
+  RUSTFLAGS: "-D warnings"
+
+jobs:
+  fmt:
+    name: rustfmt
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - run: cargo fmt --all --check
+
+  clippy:
+    name: clippy (${{ matrix.features }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - features: "--no-default-features"
+          - features: "" # default features
+          - features: "--features full"
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo clippy --locked --all-targets ${{ matrix.features }}
+
+  docs:
+    name: doc
+    runs-on: ubuntu-latest
+    env:
+      RUSTDOCFLAGS: "-D warnings"
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      # `full` is every Rust-facing feature (python is a cdylib, doc'd separately
+      # by maturin/pyo3), so this exercises the whole documented surface.
+      - run: cargo doc --locked --no-deps --features full
+
+  test:
+    name: test (${{ matrix.name }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          # The spine, minimal: no backend at all, then the smartcore spine.
+          - { name: "core-only", features: "--no-default-features" }
+          - { name: "spine", features: "--no-default-features --features smartcore-backend" }
+          # The default install.
+          - { name: "default", features: "" }
+          # Each feature added on top of default — the realistic install shape,
+          # and enough to catch a feature that fails to compile in isolation.
+          - { name: "eda", features: "--features eda" }
+          - { name: "calibration", features: "--features calibration" }
+          - { name: "anomaly", features: "--features anomaly" }
+          - { name: "linfa", features: "--features linfa-backend" }
+          - { name: "hpo", features: "--features hpo" }
+          - { name: "diagnostics", features: "--features diagnostics" }
+          - { name: "explain", features: "--features explain" }
+          - { name: "viz", features: "--features viz" }
+          - { name: "onnx", features: "--features onnx" }
+          - { name: "registry", features: "--features registry" }
+          - { name: "monitor", features: "--features monitor" }
+          - { name: "serve", features: "--features serve" }
+          - { name: "timeseries", features: "--features timeseries" }
+          - { name: "incremental", features: "--features incremental" }
+          - { name: "automl", features: "--features automl" }
+          # Everything at once — the superset build, including both ndarray worlds.
+          - { name: "full", features: "--features full" }
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          key: ${{ matrix.name }}
+      - run: cargo test --locked ${{ matrix.features }}
+
+  # Cross-platform confidence on the default install, without multiplying the
+  # whole feature matrix across three operating systems.
+  os:
+    name: test (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [windows-latest, macos-latest]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - run: cargo test --locked
+
+  # Compile and *run* the examples (the `test` jobs only build the library and
+  # its tests), plus a compile-check of the benchmarks. The declared MSRV
+  # (`rust-version` in Cargo.toml) is enforced by cargo for consumers; we do not
+  # run a dedicated old-toolchain job, since the floor is dictated entirely by
+  # transitive engine deps and would otherwise break on every one of their bumps.
+  examples:
+    name: examples & benches
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: run every example
+        run: |
+          for ex in spine explore trust workflow backends insight portability operations specialized automl; do
+            echo "::group::$ex"
+            cargo run --locked --features full --example "$ex"
+            echo "::endgroup::"
+          done
+      - name: compile benchmarks
+        run: cargo bench --locked --features full --no-run
+
+  package:
+    name: package (publish dry-run)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      # No rust-cache here: `cargo publish` builds a copy under target/package,
+      # which the cache action's post-step chokes on.
+      # Prove the crate packages and builds from its packaged form as it would on
+      # crates.io — catches missing files, bad metadata, and path/dev-dep leaks.
+      - run: cargo publish --dry-run --locked
+
+  python:
+    name: python wheel
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+      - uses: Swatinem/rust-cache@v2
+      # The `python` feature can't be linked by `cargo test` (pyo3's
+      # extension-module defers libpython), so it is built the way it ships:
+      # as an abi3 wheel via maturin, then smoke-imported.
+      - run: pip install maturin
+      - run: maturin build --locked --release
+      - run: pip install --find-links target/wheels millwright
+      - run: python -c "import millwright; print('millwright', getattr(millwright, '__version__', 'ok'))"

millwright-0.1.0/.github/workflows/release-python.yml

@@ -0,0 +1,114 @@
+name: release-python
+
+# Build wheels for every platform and publish them to PyPI when a version tag is
+# pushed (e.g. `git tag v0.1.1 && git push --tags`). A manual run
+# (workflow_dispatch) builds and checks the wheels without publishing.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  linux:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: build wheel (${{ matrix.target }})
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          manylinux: auto
+          # `[tool.maturin] features = ["python"]` in pyproject.toml selects the
+          # feature; abi3-py39 means one wheel covers Python 3.9+.
+          args: --release --locked --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-linux-${{ matrix.target }}
+          path: dist
+
+  windows:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [x64]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+          architecture: ${{ matrix.target }}
+      - name: build wheel (${{ matrix.target }})
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --locked --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-windows-${{ matrix.target }}
+          path: dist
+
+  macos:
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target: [x86_64, aarch64]
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: build wheel (${{ matrix.target }})
+        uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --locked --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-macos-${{ matrix.target }}
+          path: dist
+
+  sdist:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - name: build sdist
+        uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: dist
+
+  release:
+    name: publish to PyPI
+    runs-on: ubuntu-latest
+    needs: [linux, windows, macos, sdist]
+    # Only publish on a version tag; a manual run just builds the wheels above.
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          merge-multiple: true
+          path: dist
+      - name: publish
+        uses: PyO3/maturin-action@v1
+        env:
+          MATURIN_PYPI_TOKEN: ${{ secrets.PYPI_API_TOKEN }}
+        with:
+          command: upload
+          args: --non-interactive --skip-existing dist/*

millwright-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+/target
+
+# Cargo.lock IS committed (Phase 8): this framework assembles young, single-
+# author engine crates, so a reproducible dependency graph is a feature. See
+# the pinning policy in Cargo.toml.
+
+# IDE
+/.idea
+/.vscode
+
+# Python / maturin
+/.venv
+/wheels
+*.pyd
+__pycache__/

millwright-0.1.0/CHANGELOG.md

@@ -0,0 +1,63 @@
+# Changelog
+
+All notable changes to Millwright are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/), and the project aims at
+[Semantic Versioning](https://semver.org/).
+
+## [Unreleased]
+
+### Added
+
+- **`LogisticRegression`** — a native, core binary classifier with genuine
+  `predict_proba`: the framework's first real `ProbaPredictor`.
+- **`calibration` feature** — `PlattScaling`, `IsotonicRegression`,
+  `reliability_curve`, and `CalibratedClassifier`, which wraps any
+  `ProbaPredictor` and returns calibrated probabilities.
+- **`anomaly` feature** — `Mahalanobis` and `KnnScore`, unified behind an
+  `OutlierDetector` trait.
+- **`eda` feature** — a polars-backed, dtype-aware `Table` (CSV/Parquet ingest
+  that lowers to the numeric `Frame`) and a typed `Profile` with an HTML report,
+  actionable alerts, and `suggest_pipeline()`.
+- **Transformers** — `Winsorize`, `PowerTransform` (Yeo-Johnson),
+  `ColumnTransformer`, and the supervised `TargetEncoder`.
+- **Convenience** — `Frame::from_csv` (dependency-free numeric loader),
+  `Table::head`.
+- **Python** — `min_max_scaler`, `simple_imputer`, `one_hot`,
+  `linear_regression`, and `evaluate()`.
+- **Examples** — `explore` (ingest → profile → pipeline) and `trust`
+  (calibration → reliability → anomaly detection).
+- **Benchmarks** — `benches/throughput.rs` (criterion): the boundary conversion
+  and core fit/predict, backing the "Rust speed" claim.
+- **One-hot ingest** — `Table::to_frame_with` / `into_dataset_with` and a
+  `CategoryEncoding` enum: lower nominal categories to 0/1 indicator columns
+  instead of ordinal codes.
+- **Schema-aware preprocessing** — `Frame` carries a per-column `Dtype`; `Table`
+  marks categoricals as it lowers; scalers / `Winsorize` / `PowerTransform` pass
+  categorical columns through untouched, and `OneHotEncoder` encodes by dtype
+  rather than a value heuristic when the schema is known.
+- **Real-data validation** — an end-to-end integration test on Quinlan's
+  PlayTennis (`tests/real_data.rs`): CSV → profile → suggested pipeline → fit.
+
+### Changed
+
+- Exact-version pins on every engine crate; `Cargo.lock` committed; a
+  feature-matrix CI (fmt, clippy `-D warnings`, docs, matrix, OS, examples,
+  benches, publish dry-run, wheel).
+- `selection.rs` split into `selection/{scoring,cv,search}`.
+- MSRV is **1.95** (dep-dictated — `sysinfo` via tract, and polars); enforced by
+  cargo via `rust-version` rather than a dedicated CI job (which would break on
+  every transitive bump). The default install needs 1.85.
+- De-staled the crate and module docs (no more "Phase 0 · the spine").
+
+### Fixed
+
+- Golden tests and the crate doctest build under every feature subset (they were
+  unconditionally referencing backend-gated types).
+- Float sorts use `f64::total_cmp`, closing a NaN-driven panic class.
+
+## [0.1.0]
+
+- Phases 0–8: the `Frame`/trait spine and smartcore backend, preprocessing and
+  model selection, a second backend (linfa) and HPO, evaluation/diagnostics/
+  explainability, ONNX export and inference, serving + drift monitoring + a model
+  registry, time-series and out-of-core estimators, AutoML, and 1.0 hardening.

millwright-0.1.0/CNAME

@@ -0,0 +1 @@
+millwright-rs.dev