lensuq 0.2.0__tar.gz

lensuq-0.2.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md pyproject.toml
+recursive-include examples *.py
+recursive-include docs *.md *.json

lensuq-0.2.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: lensuq
+Version: 0.2.0
+Summary: Quantify prediction sensitivity across alternative preprocessing pipelines
+Author: Sarseej Shrestha
+Project-URL: Repository, https://github.com/sarseej-shrestha/LensUQ
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: rich>=13
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.9; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=6; extra == "dev"
+
+# LensUQ
+
+LensUQ measures how predictions vary across a user-defined set of preprocessing pipelines.
+
+## The Problem
+
+Preprocessing is often treated as fixed, although several representations may be reasonable. A model fitted after mean imputation can disagree with an independently fitted model using median imputation. That variation is easy to miss when only one pipeline is reported.
+
+## The LensUQ Question
+
+**How dependent is this prediction on preprocessing assumptions?**
+
+For a declared pipeline space P, LensUQ fits an estimator separately in every selected universe and examines the predictions for the same held-out observations. The user decides which alternatives are defensible. LensUQ does not decide which choice is scientifically correct.
+
+## What LensUQ Is Not
+
+- **GridSearchCV:** there is no performance objective or winning configuration.
+- **An ensemble:** universe predictions are not automatically combined for deployment.
+- **An automatic preprocessing selector:** scientific suitability remains the user's judgment.
+
+## Installation
+
+Python 3.11 or newer:
+
+```bash
+python -m pip install lensuq
+```
+
+For development from a checkout:
+
+```bash
+git clone https://github.com/sarseej-shrestha/LensUQ.git
+cd LensUQ
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+```
+
+## Quick Start
+
+```python
+from lensuq import Choice, PipelineSpace
+from sklearn.datasets import load_iris
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, RobustScaler
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, _ = train_test_split(
+    X, y, test_size=0.2, stratify=y, random_state=42
+)
+space = PipelineSpace(
+    scaler=Choice(StandardScaler(), RobustScaler()),
+    model=LogisticRegression(max_iter=1000, random_state=42),
+)
+experiment = space.fit(X_train, y_train, cache=True)
+report = experiment.audit(X_test)
+print(report.most_sensitive(5))
+print(report.sample(report.most_sensitive(1).index[0]).contributions)
+```
+
+## Core Abstractions
+
+`Choice` snapshots an ordered set of cloneable sklearn transformers. It supports explicit labels and `"passthrough"`. `ParamChoice` expands finite parameter lists in declaration order. `PipelineSpace` accepts any number of ordered preprocessing stages followed by a fixed `model`. A fixed stage is allowed; a single model-only space remains supported for compatibility. `Universe` holds an ID, factor labels, and its own cloned sklearn pipeline. `Experiment` owns fitted universes and execution metadata. `AuditReport` and `SampleReport` expose data independently of terminal rendering.
+
+The first full-product combination is nominal. In a sampled run, the smallest selected Cartesian ID is nominal for that run. Neither is selected by test performance. Estimator family and settings remain fixed across universes.
+
+## Full vs Sampled Spaces
+
+`space.n_universes` gives the theoretical Cartesian size. Full enumeration uses rightmost-factor-fastest order. For a large space, sample unique IDs without constructing every pipeline:
+
+```python
+experiment = space.fit(
+    X_train,
+    y_train,
+    strategy="random",
+    n_universes=200,
+    random_state=42,
+)
+```
+
+The same seed and space give the same sorted IDs. Requests above the possible count fail. Sampled audits provide prediction metrics and exports; `report.attribution` is `None`, and `sample()` raises a clear error because classical orthogonal sums of squares are not valid for incomplete designs.
+
+## Classification
+
+Classifiers must implement `predict_proba`; probabilities are validated. Binary `experiment.predict_proba(X)` preserves the prototype sample-by-universe DataFrame for `classes_[1]`. The binary audit reports nominal and mean probability, population standard deviation, min, max, range, class counts and fractions, nominal flips, decision agreement, and vote entropy. At threshold `t`, equality predicts `classes_[1]`.
+
+Multiclass `predict_proba(X)` returns a sample × universe × class NumPy array in `experiment.classes` order. The audit reports nominal and majority class, vote agreement and entropy, per-class frequencies, mean, population standard deviation, min, max, and range. Class decisions use maximum probability; tied votes select the first class in sklearn class order. Binary and multiclass sensitivity ranking sorts by lower decision agreement, then larger probability range, then larger standard deviation, then input order.
+
+## Regression
+
+Regressors require `predict`. `experiment.predict(X)` returns a sample-by-universe DataFrame. Audits report nominal, mean, population standard deviation, min, max, range, median, and IQR. Regression ranking sorts by larger raw prediction range, then larger standard deviation, then input order. Dispersion retains the target's units; no unstable near-zero normalization is used.
+
+## Attribution
+
+On a complete equally weighted Cartesian product, LensUQ decomposes the sum of squared prediction deviations from the grand mean. For each factor, the main-effect sum of squares is `sum_l n_l (mean_l - grand_mean)^2`. Each pair uses the two-factor cell mean after subtracting its two main effects. Remaining higher-order variation is reported as `interaction_residual`. Fractions sum to approximately one when total variation is positive; all fractions are zero for exactly constant predictions.
+
+Binary attribution analyzes positive-class probability. Multiclass attribution analyzes the majority class probability for each observation by default, or a specified `class_index` passed to `audit`. Regression attribution analyzes the raw prediction. Contributions describe variation in the configured refitted pipeline experiment; they are not causal effects, p-values, or probabilities of error. Incomplete sampled designs have no attribution in this release.
+
+## Execution Reuse
+
+`cache=True` reuses fitted training transformations for identical preprocessing prefixes on the same training data. Each cached transformed array and fitted transformer is copied before reuse. Every universe still fits an independent model. The cache is local to one `fit` call and never crosses datasets. `cache=False` fits whole sklearn pipelines normally. Metadata records cache hits and training/analysis time.
+
+## Exports
+
+`report.to_dataframe()` returns sample metrics with the input index. `report.predictions`, `report.universes`, `report.samples`, and `report.attribution` expose other structured data. `to_csv(path)` writes sample metrics. `to_json(path)` writes metadata, universe coordinates, sample metrics, predictions, and attribution without fitted models. File I/O errors propagate to the caller.
+
+## Demonstrations
+
+All datasets are bundled with sklearn and use fixed seeds:
+
+```bash
+lensuq info
+lensuq demo
+lensuq demo breast-cancer
+lensuq demo wine
+lensuq demo regression
+python examples/breast_cancer_demo.py
+```
+
+The breast cancer example uses artificial missingness, a 455/114 split, three imputers, three scalers, and logistic regression. **This is a controlled prototype demonstration of preprocessing sensitivity, not a medical finding.** The wine example uses three scalers and three feature counts with multiclass logistic regression. The diabetes example uses the same factor structure with Ridge regression. Each demo ranks actual observations; no result row is preselected.
+
+## Testing
+
+```bash
+python -m pytest
+ruff check .
+ruff format --check .
+```
+
+CI runs these commands and the breast cancer demo on Python 3.11 and 3.14.
+
+## Limitations
+
+Spaces are finite and unconditional Cartesian products. Factor alternatives are equally weighted, so duplicate semantic options can change the implied measure. Attribution requires a complete balanced product. Prefix caching assumes sklearn-compatible transformers without external mutable state. Users must choose scientifically appropriate factors, train/test splits, and seeds for stochastic estimators. LensUQ does not estimate calibration, correctness, confidence intervals, or data-sampling uncertainty. Probability metrics require `predict_proba`.
+
+## Future Work
+
+Potential extensions include constrained spaces, attribution estimators for incomplete designs, repeated data and model seeds, richer provenance, and non-sklearn backends. These are research directions, not current features. The [research vault](vault/00%20Home.md) records the project rationale and open questions.

lensuq-0.2.0/README.md

@@ -0,0 +1,139 @@
+# LensUQ
+
+LensUQ measures how predictions vary across a user-defined set of preprocessing pipelines.
+
+## The Problem
+
+Preprocessing is often treated as fixed, although several representations may be reasonable. A model fitted after mean imputation can disagree with an independently fitted model using median imputation. That variation is easy to miss when only one pipeline is reported.
+
+## The LensUQ Question
+
+**How dependent is this prediction on preprocessing assumptions?**
+
+For a declared pipeline space P, LensUQ fits an estimator separately in every selected universe and examines the predictions for the same held-out observations. The user decides which alternatives are defensible. LensUQ does not decide which choice is scientifically correct.
+
+## What LensUQ Is Not
+
+- **GridSearchCV:** there is no performance objective or winning configuration.
+- **An ensemble:** universe predictions are not automatically combined for deployment.
+- **An automatic preprocessing selector:** scientific suitability remains the user's judgment.
+
+## Installation
+
+Python 3.11 or newer:
+
+```bash
+python -m pip install lensuq
+```
+
+For development from a checkout:
+
+```bash
+git clone https://github.com/sarseej-shrestha/LensUQ.git
+cd LensUQ
+python3 -m venv .venv
+source .venv/bin/activate
+python -m pip install -e '.[dev]'
+```
+
+## Quick Start
+
+```python
+from lensuq import Choice, PipelineSpace
+from sklearn.datasets import load_iris
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler, RobustScaler
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, _ = train_test_split(
+    X, y, test_size=0.2, stratify=y, random_state=42
+)
+space = PipelineSpace(
+    scaler=Choice(StandardScaler(), RobustScaler()),
+    model=LogisticRegression(max_iter=1000, random_state=42),
+)
+experiment = space.fit(X_train, y_train, cache=True)
+report = experiment.audit(X_test)
+print(report.most_sensitive(5))
+print(report.sample(report.most_sensitive(1).index[0]).contributions)
+```
+
+## Core Abstractions
+
+`Choice` snapshots an ordered set of cloneable sklearn transformers. It supports explicit labels and `"passthrough"`. `ParamChoice` expands finite parameter lists in declaration order. `PipelineSpace` accepts any number of ordered preprocessing stages followed by a fixed `model`. A fixed stage is allowed; a single model-only space remains supported for compatibility. `Universe` holds an ID, factor labels, and its own cloned sklearn pipeline. `Experiment` owns fitted universes and execution metadata. `AuditReport` and `SampleReport` expose data independently of terminal rendering.
+
+The first full-product combination is nominal. In a sampled run, the smallest selected Cartesian ID is nominal for that run. Neither is selected by test performance. Estimator family and settings remain fixed across universes.
+
+## Full vs Sampled Spaces
+
+`space.n_universes` gives the theoretical Cartesian size. Full enumeration uses rightmost-factor-fastest order. For a large space, sample unique IDs without constructing every pipeline:
+
+```python
+experiment = space.fit(
+    X_train,
+    y_train,
+    strategy="random",
+    n_universes=200,
+    random_state=42,
+)
+```
+
+The same seed and space give the same sorted IDs. Requests above the possible count fail. Sampled audits provide prediction metrics and exports; `report.attribution` is `None`, and `sample()` raises a clear error because classical orthogonal sums of squares are not valid for incomplete designs.
+
+## Classification
+
+Classifiers must implement `predict_proba`; probabilities are validated. Binary `experiment.predict_proba(X)` preserves the prototype sample-by-universe DataFrame for `classes_[1]`. The binary audit reports nominal and mean probability, population standard deviation, min, max, range, class counts and fractions, nominal flips, decision agreement, and vote entropy. At threshold `t`, equality predicts `classes_[1]`.
+
+Multiclass `predict_proba(X)` returns a sample × universe × class NumPy array in `experiment.classes` order. The audit reports nominal and majority class, vote agreement and entropy, per-class frequencies, mean, population standard deviation, min, max, and range. Class decisions use maximum probability; tied votes select the first class in sklearn class order. Binary and multiclass sensitivity ranking sorts by lower decision agreement, then larger probability range, then larger standard deviation, then input order.
+
+## Regression
+
+Regressors require `predict`. `experiment.predict(X)` returns a sample-by-universe DataFrame. Audits report nominal, mean, population standard deviation, min, max, range, median, and IQR. Regression ranking sorts by larger raw prediction range, then larger standard deviation, then input order. Dispersion retains the target's units; no unstable near-zero normalization is used.
+
+## Attribution
+
+On a complete equally weighted Cartesian product, LensUQ decomposes the sum of squared prediction deviations from the grand mean. For each factor, the main-effect sum of squares is `sum_l n_l (mean_l - grand_mean)^2`. Each pair uses the two-factor cell mean after subtracting its two main effects. Remaining higher-order variation is reported as `interaction_residual`. Fractions sum to approximately one when total variation is positive; all fractions are zero for exactly constant predictions.
+
+Binary attribution analyzes positive-class probability. Multiclass attribution analyzes the majority class probability for each observation by default, or a specified `class_index` passed to `audit`. Regression attribution analyzes the raw prediction. Contributions describe variation in the configured refitted pipeline experiment; they are not causal effects, p-values, or probabilities of error. Incomplete sampled designs have no attribution in this release.
+
+## Execution Reuse
+
+`cache=True` reuses fitted training transformations for identical preprocessing prefixes on the same training data. Each cached transformed array and fitted transformer is copied before reuse. Every universe still fits an independent model. The cache is local to one `fit` call and never crosses datasets. `cache=False` fits whole sklearn pipelines normally. Metadata records cache hits and training/analysis time.
+
+## Exports
+
+`report.to_dataframe()` returns sample metrics with the input index. `report.predictions`, `report.universes`, `report.samples`, and `report.attribution` expose other structured data. `to_csv(path)` writes sample metrics. `to_json(path)` writes metadata, universe coordinates, sample metrics, predictions, and attribution without fitted models. File I/O errors propagate to the caller.
+
+## Demonstrations
+
+All datasets are bundled with sklearn and use fixed seeds:
+
+```bash
+lensuq info
+lensuq demo
+lensuq demo breast-cancer
+lensuq demo wine
+lensuq demo regression
+python examples/breast_cancer_demo.py
+```
+
+The breast cancer example uses artificial missingness, a 455/114 split, three imputers, three scalers, and logistic regression. **This is a controlled prototype demonstration of preprocessing sensitivity, not a medical finding.** The wine example uses three scalers and three feature counts with multiclass logistic regression. The diabetes example uses the same factor structure with Ridge regression. Each demo ranks actual observations; no result row is preselected.
+
+## Testing
+
+```bash
+python -m pytest
+ruff check .
+ruff format --check .
+```
+
+CI runs these commands and the breast cancer demo on Python 3.11 and 3.14.
+
+## Limitations
+
+Spaces are finite and unconditional Cartesian products. Factor alternatives are equally weighted, so duplicate semantic options can change the implied measure. Attribution requires a complete balanced product. Prefix caching assumes sklearn-compatible transformers without external mutable state. Users must choose scientifically appropriate factors, train/test splits, and seeds for stochastic estimators. LensUQ does not estimate calibration, correctness, confidence intervals, or data-sampling uncertainty. Probability metrics require `predict_proba`.
+
+## Future Work
+
+Potential extensions include constrained spaces, attribution estimators for incomplete designs, repeated data and model seeds, richer provenance, and non-sklearn backends. These are research directions, not current features. The [research vault](vault/00%20Home.md) records the project rationale and open questions.

lensuq-0.2.0/docs/api.md

@@ -0,0 +1,11 @@
+# API contract
+
+`Choice(*transformers, labels=None, name=None)` stores cloned ordered alternatives. `"passthrough"` is permitted. `ParamChoice(EstimatorClass, parameter=[values], ...)` expands a finite Cartesian product; labels show parameter names and values. Duplicate labels and empty levels are rejected.
+
+`PipelineSpace(stage=Choice(...), ..., model=estimator)` uses keyword order for preprocessing order. `model` is fixed and must be a sklearn classifier with `predict_proba` or a regressor with `predict`. `n_universes`, `factors`, `metadata`, and `universes` expose the declared space. `select_universes(strategy="full"|"random", n_universes=None, random_state=None)` returns fresh universes. `fit(X, y, strategy=..., n_universes=..., random_state=..., cache=False)` fits independent models.
+
+`Experiment.predict_proba(X)` returns a DataFrame for binary classification and a sample × universe × class array for multiclass. `predict(X)` returns a regression DataFrame. `audit(X, threshold=0.5, class_index=None)` returns an `AuditReport`. `most_sensitive(n)` and `explain(index)` use the latest successful audit.
+
+`AuditReport.dataframe` and `to_dataframe()` contain sample metrics. `predictions`, `universes`, `samples`, `metadata`, and `attribution` expose further results. Binary long-form predictions include the positive-class `probability`; multiclass predictions include `winning_probability` and every `class_N_probability`. `contributions` and `level_means` require full factorial coverage. `most_sensitive(n)` ranks sample rows. `sample(index)` returns a `SampleReport` for full designs. `to_csv(path)` and `to_json(path)` write deterministic schema structures; timing fields are measured per run.
+
+Sample indices must be unique, flat, and nonmissing. DataFrame X and Series y must have matching index order. The first executed universe is the nominal reference. Fitted universe pipelines are inspectable; mutating them invalidates experiment results.

lensuq-0.2.0/docs/demo-results.json

@@ -0,0 +1,154 @@
+{
+  "python": "3.14.3",
+  "numpy": "2.5.4",
+  "pandas": "3.0.6",
+  "scikit_learn": "1.9.1",
+  "training_observations": 455,
+  "test_observations": 114,
+  "universes": 9,
+  "missing_cells": 532,
+  "eligible_cells": 3414,
+  "disagreement_observations": 6,
+  "most_sensitive_sample": 385,
+  "metrics": {
+    "nominal_probability": 0.16790800962770763,
+    "mean_probability": 0.3304226179520909,
+    "standard_deviation": 0.18121864501908155,
+    "minimum_probability": 0.14890945956058965,
+    "maximum_probability": 0.6041025790595507,
+    "probability_range": 0.455193119498961,
+    "positive_prediction_count": 3,
+    "negative_prediction_count": 6,
+    "positive_prediction_fraction": 0.3333333333333333,
+    "negative_prediction_fraction": 0.6666666666666666,
+    "decision_agreement": 0.6666666666666666,
+    "class_flip_count": 3,
+    "decision_entropy": 0.9182958340544896,
+    "nominal_decision": 0,
+    "majority_decision": 0,
+    "perfectly_stable": false,
+    "nominal_class": 0,
+    "majority_class": 0
+  },
+  "contributions": {
+    "imputer": 0.0009599943034101484,
+    "scaler": 0.9962226546914351,
+    "interaction_residual": 0.0028173510051548215
+  },
+  "total_sum_of_squares": 0.29556177572296705,
+  "predictions": [
+    {
+      "universe_id": 0,
+      "choice:imputer": "mean",
+      "choice:scaler": "standard",
+      "probability": 0.16790800962770763,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 1,
+      "choice:imputer": "mean",
+      "choice:scaler": "robust",
+      "probability": 0.25341603601953744,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 2,
+      "choice:imputer": "mean",
+      "choice:scaler": "minmax",
+      "probability": 0.5729237121115737,
+      "predicted_class": 1
+    },
+    {
+      "universe_id": 3,
+      "choice:imputer": "median",
+      "choice:scaler": "standard",
+      "probability": 0.15788403044606353,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 4,
+      "choice:imputer": "median",
+      "choice:scaler": "robust",
+      "probability": 0.24743639488866442,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 5,
+      "choice:imputer": "median",
+      "choice:scaler": "minmax",
+      "probability": 0.5639892924532462,
+      "predicted_class": 1
+    },
+    {
+      "universe_id": 6,
+      "choice:imputer": "knn_5",
+      "choice:scaler": "standard",
+      "probability": 0.14890945956058965,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 7,
+      "choice:imputer": "knn_5",
+      "choice:scaler": "robust",
+      "probability": 0.2572340474018845,
+      "predicted_class": 0
+    },
+    {
+      "universe_id": 8,
+      "choice:imputer": "knn_5",
+      "choice:scaler": "minmax",
+      "probability": 0.6041025790595507,
+      "predicted_class": 1
+    }
+  ],
+  "level_means": [
+    {
+      "factor": "imputer",
+      "level": "mean",
+      "mean_probability": 0.33141591925293956,
+      "universe_count": 3
+    },
+    {
+      "factor": "imputer",
+      "level": "median",
+      "mean_probability": 0.32310323926265805,
+      "universe_count": 3
+    },
+    {
+      "factor": "imputer",
+      "level": "knn_5",
+      "mean_probability": 0.3367486953406749,
+      "universe_count": 3
+    },
+    {
+      "factor": "scaler",
+      "level": "standard",
+      "mean_probability": 0.1582338332114536,
+      "universe_count": 3
+    },
+    {
+      "factor": "scaler",
+      "level": "robust",
+      "mean_probability": 0.2526954927700288,
+      "universe_count": 3
+    },
+    {
+      "factor": "scaler",
+      "level": "minmax",
+      "mean_probability": 0.5803385278747902,
+      "universe_count": 3
+    }
+  ],
+  "top_ten": [
+    385,
+    41,
+    205,
+    363,
+    261,
+    542,
+    128,
+    375,
+    537,
+    247
+  ]
+}

lensuq-0.2.0/docs/methodology.md

@@ -0,0 +1,9 @@
+# Measurement methodology
+
+LensUQ measures variation over a finite user-defined set of preprocessing alternatives. Each universe receives the same training rows and an independently cloned estimator. Each preprocessing chain is fitted only on training data. Test observations are transformed with that universe's fitted chain. The framework does not rank pipelines by predictive performance.
+
+For a sample, classification decisions are votes across universes. Decision agreement is the largest class count divided by the universe count. Decision entropy is Shannon entropy in bits of class frequencies. Probability dispersion uses population standard deviation. Multiclass probability metrics are computed for every class separately. Regression dispersion uses raw target units and percentile IQR.
+
+On a complete Cartesian product, all factor contrasts are orthogonal under equal universe weighting. For values v_u, total SS is sum `(v_u - mean(v))²`. A factor main effect is sum over levels of `n_l (mean_l - mean(v))²`. For pair A,B, each cell contributes `n_ab (mean_ab - mean_a - mean_b + mean(v))²`. The residual is the remaining total SS after main and pairwise effects and may contain third and higher order interactions. Numerical roundoff is clipped at zero. Exactly constant values have zero fractions.
+
+For multiclass, default attribution selects each observation's majority class probability; `class_index` selects a single probability column across all observations. For binary, the second class probability is used. For regression, the predicted value is used. Sampled designs retain their sample metrics but do not receive this decomposition. No inferential, causal, or calibration claim follows from these fractions.

lensuq-0.2.0/examples/breast_cancer_demo.py

@@ -0,0 +1,9 @@
+"""Run the controlled demonstration after installing LensUQ in editable mode.
+
+Missingness is artificial. This demonstration is not a medical finding.
+"""
+
+from lensuq.demo import run_demo
+
+if __name__ == "__main__":
+    run_demo()

lensuq-0.2.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lensuq"
+version = "0.2.0"
+description = "Quantify prediction sensitivity across alternative preprocessing pipelines"
+readme = "README.md"
+requires-python = ">=3.11"
+authors = [{name = "Sarseej Shrestha"}]
+dependencies = [
+  "numpy>=1.24",
+  "pandas>=2.0",
+  "scikit-learn>=1.3",
+  "rich>=13",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8", "ruff>=0.9", "build>=1.2", "twine>=6"]
+
+[project.scripts]
+lensuq = "lensuq.cli:main"
+
+[project.urls]
+Repository = "https://github.com/sarseej-shrestha/LensUQ"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+filterwarnings = ["error"]
+
+[tool.ruff]
+target-version = "py311"
+line-length = 88
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]

lensuq-0.2.0/setup.cfg

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

lensuq-0.2.0/src/lensuq/__init__.py

@@ -0,0 +1,18 @@
+"""Prediction sensitivity across preprocessing choices."""
+
+from lensuq.choice import Choice, ParamChoice
+from lensuq.experiment import Experiment
+from lensuq.report import AuditReport, SampleReport
+from lensuq.space import PipelineSpace
+from lensuq.universe import Universe
+
+__all__ = [
+    "Choice",
+    "ParamChoice",
+    "PipelineSpace",
+    "Universe",
+    "Experiment",
+    "AuditReport",
+    "SampleReport",
+]
+__version__ = "0.2.0"

lensuq-0.2.0/src/lensuq/__main__.py

@@ -0,0 +1,5 @@
+"""Support python -m lensuq."""
+
+from lensuq.cli import main
+
+raise SystemExit(main())