mipy-impute 2.1.0__tar.gz

mipy_impute-2.1.0/CHANGELOG.md

@@ -0,0 +1,38 @@
+# Changelog
+
+## 2.1.0 (2026-10-16)
+
+For users with their own data.
+
+* `mipy.analyze()`: one call from a table to a benchmark of the methods, the
+  completed data, figures (PNG and PDF), tables (CSV and Excel) and a
+  self-contained HTML report. Every stage after the data check is protected,
+  so a failing method or figure is reported and the rest still runs.
+* `mipy.prepare_data()` and `mipy.read_table()`: read CSV (comma, semicolon or
+  tab), Excel, TSV and Parquet; find the ID, visit, feature, clinical and
+  survival columns by name and content; read `NA`, `<LOD`, `n/a`, decimal
+  commas; turn visit labels such as `V2` or `week 4` into numbers; accept long
+  tables; explain every decision; clear `DataError` messages.
+* Patients are ordered by their ID, so the row order of the file does not
+  change the results.
+* `mipy.example_cohort()`: a synthetic cohort laid out like the GSE65622
+  analysis files, for trying MIPY and as a template.
+* Command line: `mipy analyze | check | impute | example | methods`.
+* Figures module `mipy.plots` (no pyplot; works in scripts, terminals and
+  Jupyter) and report module `mipy.report`.
+* `Result.show()` displays tables and figures inline in Jupyter.
+* Exploratory survival screen when the table has a survival time and event.
+* matplotlib and openpyxl are now core dependencies.
+* GAIN now trains for 1,000 iterations by default (hyperimpute's default; was
+  100). The paper pipeline sets its own value, so its results do not change.
+* `mipy.impute()` also accepts a file path.
+
+## 2.0.0 (2026-10-15)
+
+* MICE-Long and MICE-LongMNAR; multiple-imputation versions of softImpute,
+  missForest and miceforest; Rubin's rules and interval coverage.
+* LOD masking; repeated maskings with Monte Carlo standard errors.
+* Agreement with the R packages (softImpute, missForest, mice, imputeLCMD),
+  with mice's ridge fallback when `norm.boot` stops on rank-deficient samples.
+* Data handling with pandas, polars and DuckDB; chunked imputation.
+* Survival endpoint checks and pooled univariate Cox models.

mipy_impute-2.1.0/CITATION.cff

@@ -0,0 +1,24 @@
+cff-version: 1.2.0
+message: "If you use MIPY, please cite it as below."
+title: "MIPY: Missing-data Imputation in Python for high-dimensional longitudinal data"
+version: 2.1.0
+date-released: 2026-10-16
+license: MIT
+authors:
+  - family-names: Kumar
+    given-names: Neelesh
+    orcid: "https://orcid.org/0009-0007-5435-003X"
+    affiliation: "Indian Institute of Technology (ISM) Dhanbad"
+  - family-names: Bhattacharjee
+    given-names: Atanu
+    orcid: "https://orcid.org/0000-0002-5757-5513"
+    affiliation: "University of Dundee"
+  - family-names: Vishwakarma
+    given-names: Gajendra K.
+    orcid: "https://orcid.org/0000-0002-2804-4334"
+    affiliation: "Indian Institute of Technology (ISM) Dhanbad"
+  - family-names: Majumdar
+    given-names: Tanmoy
+    orcid: "https://orcid.org/0009-0003-2297-7808"
+    affiliation: "Indian Institute of Technology (ISM) Dhanbad"
+keywords: [missing data, imputation, multiple imputation, longitudinal data, proteomics]

mipy_impute-2.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Neelesh Kumar, Atanu Bhattacharjee, Gajendra K. Vishwakarma, Tanmoy Majumdar
+
+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.

mipy_impute-2.1.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include README.md LICENSE CHANGELOG.md CITATION.cff
+recursive-include tests *.py
+recursive-include docs *.md *.png
+recursive-include src/mipy/r *.R
+include src/mipy/data/README.txt
+global-exclude *.pyc __pycache__ .mipy_cache
+prune notebooks
+prune build
+prune dist

mipy_impute-2.1.0/PKG-INFO

@@ -0,0 +1,266 @@
+Metadata-Version: 2.4
+Name: mipy-impute
+Version: 2.1.0
+Summary: MIPY: missing-data imputation and benchmarking in Python for high-dimensional longitudinal data
+Author: Atanu Bhattacharjee, Gajendra K. Vishwakarma, Tanmoy Majumdar
+Author-email: Neelesh Kumar <23dr0092@iitism.ac.in>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/neelesh2302-creator/mipy
+Project-URL: Documentation, https://github.com/neelesh2302-creator/mipy/tree/main/docs
+Project-URL: Issues, https://github.com/neelesh2302-creator/mipy/issues
+Keywords: missing data,imputation,multiple imputation,longitudinal,proteomics,benchmark
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Medical Science Apps.
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23
+Requires-Dist: pandas>=1.5
+Requires-Dist: scipy>=1.9
+Requires-Dist: scikit-learn>=1.2
+Requires-Dist: psutil>=5.9
+Requires-Dist: matplotlib>=3.6
+Requires-Dist: openpyxl>=3.0
+Provides-Extra: ml
+Requires-Dist: miceforest>=6; extra == "ml"
+Requires-Dist: lightgbm>=4; extra == "ml"
+Provides-Extra: automl
+Requires-Dist: hyperimpute; extra == "automl"
+Provides-Extra: bigdata
+Requires-Dist: polars>=1.0; extra == "bigdata"
+Requires-Dist: duckdb>=1.0; extra == "bigdata"
+Provides-Extra: plot
+Provides-Extra: all
+Requires-Dist: miceforest>=6; extra == "all"
+Requires-Dist: lightgbm>=4; extra == "all"
+Requires-Dist: polars>=1.0; extra == "all"
+Requires-Dist: duckdb>=1.0; extra == "all"
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == "test"
+Dynamic: license-file
+
+# MIPY: Missing-data Imputation in Python
+
+[![PyPI](https://img.shields.io/pypi/v/mipy-impute.svg)](https://pypi.org/project/mipy-impute/)
+[![Python](https://img.shields.io/pypi/pyversions/mipy-impute.svg)](https://pypi.org/project/mipy-impute/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/neelesh2302-creator/mipy/blob/main/LICENSE)
+
+MIPY finds out which imputation method works best on **your** data, fills in
+the missing values with it, and gives you the tables, figures and a report to
+show for it. It is built for **high-dimensional longitudinal data**: many
+variables (for example hundreds of proteins) measured repeatedly on the same
+patients, as in the serum proteomics series GSE65622.
+
+```python
+import mipy
+res = mipy.analyze("my_data.csv")      # one line: benchmark, impute, figures, report
+```
+
+That call:
+
+1. reads the table and works out which column is the patient ID, which is the
+   visit, which are features, clinical covariates and survival times (and
+   tells you, so you can correct it);
+2. hides 20% of the values you **do** have, under three assumptions about why
+   values go missing (completely at random, depending on visit and clinical
+   data, or because they are low), repeats this three times, and asks every
+   method to fill them in;
+3. scores each method against the hidden true values (nRMSE within each
+   feature; 1.00 = filling in the feature's mean), with Monte Carlo standard
+   errors, the share of features where the method beats the mean, whether
+   each patient's visit-to-visit variation is kept, and, for multiple
+   imputation, whether the 95% intervals are honest;
+4. fills in your real missing values with the best method (and gives *m*
+   completed tables from the best multiple-imputation method);
+5. runs an exploratory survival screen when the table has a survival time and
+   an event column;
+6. writes everything into one folder, with an HTML report that explains each
+   result in plain language.
+
+![Accuracy of the methods on the example cohort](https://raw.githubusercontent.com/neelesh2302-creator/mipy/main/docs/images/accuracy.png)
+
+## Install
+
+```bash
+pip install mipy-impute
+```
+
+Python 3.9 or newer, on Windows, macOS or Linux. Optional extras add methods:
+
+```bash
+pip install "mipy-impute[ml]"        # miceforest (LightGBM)
+pip install "mipy-impute[automl]"    # HyperImpute and GAIN (needs PyTorch)
+pip install "mipy-impute[bigdata]"   # polars and DuckDB for very large tables
+```
+
+Methods whose package is missing are skipped with a message that says what to
+install; nothing fails.
+
+## Try it in one minute
+
+```python
+import mipy
+
+df = mipy.example_cohort()             # synthetic cohort laid out like GSE65622
+res = mipy.analyze(df, out="example_results", methods="quick", repeats=1)
+res.show()                             # tables and figures; inline in Jupyter
+```
+
+Or from a terminal (Command Prompt, PowerShell, or a shell):
+
+```bash
+mipy example example.csv
+mipy analyze example.csv --methods quick --repeats 1 --open
+```
+
+## Your own data
+
+One row per patient visit, like this (any column names work):
+
+| Patient_ID | sampling_point | EN-RAGE | GDF-15 | ... | RFS | event | trg_score |
+|---|---|---|---|---|---|---|---|
+| 1 | 1 | 59.08 | 1203.4 | ... | 2727 | 0 | 4 |
+| 1 | 2 | 52.19 |  | ... | 2697 | 0 | 4 |
+| 2 | 1 |  | 980.1 | ... | 1579 | 1 | 2 |
+
+* an **ID** column and a **visit** column (optional, but needed by the
+  longitudinal methods),
+* many **numeric feature** columns with empty cells where values are missing
+  (`NA`, `n/a`, `<LOD`, `ND` and similar entries are read as missing),
+* optional **clinical** columns (few distinct values: stage, grade, batch),
+* optional **survival** columns (a time and a 0/1 event).
+
+CSV, Excel, TSV and Parquet files work, and so do pandas DataFrames. Check how
+MIPY reads a file before running anything:
+
+```bash
+mipy check my_data.csv
+```
+
+If a column is detected wrongly, say which is which:
+
+```python
+res = mipy.analyze("my_data.xlsx", id_col="Patient_ID", time_col="sampling_point",
+                   features="EN-RAGE:Prot_496",            # a range of columns, or a list
+                   clinical=["trg_score", "ypn_stage"], survival=("RFS", "event"),
+                   out="my_results")
+```
+
+More in [docs/your_data.md](https://github.com/neelesh2302-creator/mipy/blob/main/docs/your_data.md).
+
+## What you get
+
+```
+my_results/
+  report.html            all results, figures embedded, with explanations
+  figures/               fig01_missingness ... fig09_survival  (PNG and PDF)
+  tables/                accuracy_summary.csv, decision.csv, ... and mipy_results.xlsx
+  completed_data/        completed_<best method>.csv and completed_<MI method>_draw1..5.csv
+  run_log.txt            every step, warnings and error details
+```
+
+| Figure | Shows |
+|---|---|
+| missingness | where values are missing, and whether low-level features miss more often |
+| masking | which values each masking design hid |
+| accuracy | nRMSE of every method under every mechanism, with Monte Carlo intervals |
+| nrmse_per_feature | the spread of the error across features |
+| sd_ratio | whether each patient's visit-to-visit variation is kept |
+| coverage | calibration of multiple imputation (95% intervals) |
+| runtime | seconds per run |
+| imputed_vs_observed | your real missing values as filled in, against the observed values |
+| survival | exploratory Cox screen (when survival columns exist) |
+
+In Python, `res` holds the same results: `res.summary`, `res.decision`,
+`res.completed`, `res.completed_draws`, `res.survival`, `res.tables`,
+`res.figures`, `res.warnings`.
+
+## Choosing methods
+
+| `methods=` | Methods | Time on 288 visits x 507 proteins, 9 maskings* |
+|---|---|---|
+| `"quick"` | Mean, LOCF, KNN, softImpute, MinProb, QRILC, MICE-Long | about 5 min |
+| `"standard"` (default) | quick + Median, MICE-Bayes, sklearn-II, MICE-LongMNAR | 10 to 20 min |
+| `"complete"` | standard + missForest, miceforest, HyperImpute, GAIN | 2 h or more |
+| `"all"` | complete + the multiple-imputation versions and the exact imputeLCMD variants | longer |
+
+\*one process on a 2-core machine; the example cohort takes about 3 minutes
+with "standard". `n_workers="auto"` runs several methods at once, and runs
+already finished are reused if you stop and start again.
+
+| Method | Family | Multiple imputation | Uses patients | Peer-reviewed description |
+|---|---|---|---|---|
+| Mean, Median | naive | no | no | no |
+| LOCF | longitudinal rule | no | yes | no |
+| KNN | neighbour | no | no | yes (Troyanskaya et al. 2001) |
+| softImpute | low-rank | no | no | yes (Mazumder et al. 2010) |
+| MICE-Bayes | chained equations | yes | no | yes (van Buuren & Groothuis-Oudshoorn 2011) |
+| missForest | chained equations | no | no | yes (Stekhoven & Buhlmann 2012) |
+| sklearn-II | chained equations | no | no | no (scikit-learn IterativeImputer) |
+| miceforest | chained equations | no | no | no |
+| HyperImpute | AutoML | no | no | yes (Jarrett et al. 2022) |
+| GAIN | generative | no | no | yes (Yoon et al. 2018) |
+| MinProb, QRILC | left-censored | no | no | yes (Lazar et al. 2016) |
+| **MICE-Long** | longitudinal chained | yes | yes | new in MIPY |
+| **MICE-LongMNAR** | selection-model MNAR | yes | yes | new in MIPY |
+| softImpute-MI, missForest-MI, miceforest-MI | MI versions | yes | no | new in MIPY |
+
+* **MICE-Long**: chained equations that use each patient's previous visit,
+  next visit and own mean, with a patient-level bootstrap (proper multiple
+  imputation).
+* **MICE-LongMNAR**: the same with selection-model draws for values lost
+  below a detection limit; `settings={"gamma": ...}` sets the sensitivity
+  parameter.
+* softImpute, missForest, mice's `norm.boot` and imputeLCMD's MinProb and
+  QRILC are implemented in Python and checked against the R packages
+  (identical parameters; cell-level agreement r > 0.99 for softImpute).
+
+## Lower-level functions
+
+```python
+done  = mipy.impute(df, method="softImpute", id_col="Patient_ID", time_col="sampling_point", log2=True)
+draws = mipy.impute(df, method="MICE-Long", id_col="Patient_ID", time_col="sampling_point", m=5, log2=True)
+bench = mipy.benchmark(df, methods=["Mean", "softImpute", "MICE-Long"], id_col="Patient_ID",
+                       time_col="sampling_point", log2=True, mechanisms=("MCAR", "MNAR"), repeats=3)
+
+from mipy.mi import pool_estimates      # Rubin's rules over the m completions
+pooled = pool_estimates(estimates, by="term")   # columns: draw, term, beta, se
+```
+
+`mipy.list_methods()` lists every method with the function it calls and its
+evidence; `mipy.literature()` lists 14 Python imputation packages and the
+publication behind each.
+
+## Reproducing the MIPY paper
+
+`notebooks/MIPY_v2_pipeline.ipynb` runs the full GSE65622 analysis of the
+paper (all methods, multiple imputation, MNAR sensitivity, agreement with R,
+data handling up to millions of patients, a synthetic second cohort, the
+survival screen) and writes every number, table and figure.
+
+## Tests
+
+```bash
+pip install "mipy-impute[all,test]"
+pytest
+```
+
+## Citation
+
+See [CITATION.cff](https://github.com/neelesh2302-creator/mipy/blob/main/CITATION.cff).
+If you use MIPY, please cite the MIPY paper and the publication of each method
+you report (`mipy.list_methods()` gives the reference key).
+
+## Licence
+
+MIT

mipy_impute-2.1.0/README.md

@@ -0,0 +1,215 @@
+# MIPY: Missing-data Imputation in Python
+
+[![PyPI](https://img.shields.io/pypi/v/mipy-impute.svg)](https://pypi.org/project/mipy-impute/)
+[![Python](https://img.shields.io/pypi/pyversions/mipy-impute.svg)](https://pypi.org/project/mipy-impute/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/neelesh2302-creator/mipy/blob/main/LICENSE)
+
+MIPY finds out which imputation method works best on **your** data, fills in
+the missing values with it, and gives you the tables, figures and a report to
+show for it. It is built for **high-dimensional longitudinal data**: many
+variables (for example hundreds of proteins) measured repeatedly on the same
+patients, as in the serum proteomics series GSE65622.
+
+```python
+import mipy
+res = mipy.analyze("my_data.csv")      # one line: benchmark, impute, figures, report
+```
+
+That call:
+
+1. reads the table and works out which column is the patient ID, which is the
+   visit, which are features, clinical covariates and survival times (and
+   tells you, so you can correct it);
+2. hides 20% of the values you **do** have, under three assumptions about why
+   values go missing (completely at random, depending on visit and clinical
+   data, or because they are low), repeats this three times, and asks every
+   method to fill them in;
+3. scores each method against the hidden true values (nRMSE within each
+   feature; 1.00 = filling in the feature's mean), with Monte Carlo standard
+   errors, the share of features where the method beats the mean, whether
+   each patient's visit-to-visit variation is kept, and, for multiple
+   imputation, whether the 95% intervals are honest;
+4. fills in your real missing values with the best method (and gives *m*
+   completed tables from the best multiple-imputation method);
+5. runs an exploratory survival screen when the table has a survival time and
+   an event column;
+6. writes everything into one folder, with an HTML report that explains each
+   result in plain language.
+
+![Accuracy of the methods on the example cohort](https://raw.githubusercontent.com/neelesh2302-creator/mipy/main/docs/images/accuracy.png)
+
+## Install
+
+```bash
+pip install mipy-impute
+```
+
+Python 3.9 or newer, on Windows, macOS or Linux. Optional extras add methods:
+
+```bash
+pip install "mipy-impute[ml]"        # miceforest (LightGBM)
+pip install "mipy-impute[automl]"    # HyperImpute and GAIN (needs PyTorch)
+pip install "mipy-impute[bigdata]"   # polars and DuckDB for very large tables
+```
+
+Methods whose package is missing are skipped with a message that says what to
+install; nothing fails.
+
+## Try it in one minute
+
+```python
+import mipy
+
+df = mipy.example_cohort()             # synthetic cohort laid out like GSE65622
+res = mipy.analyze(df, out="example_results", methods="quick", repeats=1)
+res.show()                             # tables and figures; inline in Jupyter
+```
+
+Or from a terminal (Command Prompt, PowerShell, or a shell):
+
+```bash
+mipy example example.csv
+mipy analyze example.csv --methods quick --repeats 1 --open
+```
+
+## Your own data
+
+One row per patient visit, like this (any column names work):
+
+| Patient_ID | sampling_point | EN-RAGE | GDF-15 | ... | RFS | event | trg_score |
+|---|---|---|---|---|---|---|---|
+| 1 | 1 | 59.08 | 1203.4 | ... | 2727 | 0 | 4 |
+| 1 | 2 | 52.19 |  | ... | 2697 | 0 | 4 |
+| 2 | 1 |  | 980.1 | ... | 1579 | 1 | 2 |
+
+* an **ID** column and a **visit** column (optional, but needed by the
+  longitudinal methods),
+* many **numeric feature** columns with empty cells where values are missing
+  (`NA`, `n/a`, `<LOD`, `ND` and similar entries are read as missing),
+* optional **clinical** columns (few distinct values: stage, grade, batch),
+* optional **survival** columns (a time and a 0/1 event).
+
+CSV, Excel, TSV and Parquet files work, and so do pandas DataFrames. Check how
+MIPY reads a file before running anything:
+
+```bash
+mipy check my_data.csv
+```
+
+If a column is detected wrongly, say which is which:
+
+```python
+res = mipy.analyze("my_data.xlsx", id_col="Patient_ID", time_col="sampling_point",
+                   features="EN-RAGE:Prot_496",            # a range of columns, or a list
+                   clinical=["trg_score", "ypn_stage"], survival=("RFS", "event"),
+                   out="my_results")
+```
+
+More in [docs/your_data.md](https://github.com/neelesh2302-creator/mipy/blob/main/docs/your_data.md).
+
+## What you get
+
+```
+my_results/
+  report.html            all results, figures embedded, with explanations
+  figures/               fig01_missingness ... fig09_survival  (PNG and PDF)
+  tables/                accuracy_summary.csv, decision.csv, ... and mipy_results.xlsx
+  completed_data/        completed_<best method>.csv and completed_<MI method>_draw1..5.csv
+  run_log.txt            every step, warnings and error details
+```
+
+| Figure | Shows |
+|---|---|
+| missingness | where values are missing, and whether low-level features miss more often |
+| masking | which values each masking design hid |
+| accuracy | nRMSE of every method under every mechanism, with Monte Carlo intervals |
+| nrmse_per_feature | the spread of the error across features |
+| sd_ratio | whether each patient's visit-to-visit variation is kept |
+| coverage | calibration of multiple imputation (95% intervals) |
+| runtime | seconds per run |
+| imputed_vs_observed | your real missing values as filled in, against the observed values |
+| survival | exploratory Cox screen (when survival columns exist) |
+
+In Python, `res` holds the same results: `res.summary`, `res.decision`,
+`res.completed`, `res.completed_draws`, `res.survival`, `res.tables`,
+`res.figures`, `res.warnings`.
+
+## Choosing methods
+
+| `methods=` | Methods | Time on 288 visits x 507 proteins, 9 maskings* |
+|---|---|---|
+| `"quick"` | Mean, LOCF, KNN, softImpute, MinProb, QRILC, MICE-Long | about 5 min |
+| `"standard"` (default) | quick + Median, MICE-Bayes, sklearn-II, MICE-LongMNAR | 10 to 20 min |
+| `"complete"` | standard + missForest, miceforest, HyperImpute, GAIN | 2 h or more |
+| `"all"` | complete + the multiple-imputation versions and the exact imputeLCMD variants | longer |
+
+\*one process on a 2-core machine; the example cohort takes about 3 minutes
+with "standard". `n_workers="auto"` runs several methods at once, and runs
+already finished are reused if you stop and start again.
+
+| Method | Family | Multiple imputation | Uses patients | Peer-reviewed description |
+|---|---|---|---|---|
+| Mean, Median | naive | no | no | no |
+| LOCF | longitudinal rule | no | yes | no |
+| KNN | neighbour | no | no | yes (Troyanskaya et al. 2001) |
+| softImpute | low-rank | no | no | yes (Mazumder et al. 2010) |
+| MICE-Bayes | chained equations | yes | no | yes (van Buuren & Groothuis-Oudshoorn 2011) |
+| missForest | chained equations | no | no | yes (Stekhoven & Buhlmann 2012) |
+| sklearn-II | chained equations | no | no | no (scikit-learn IterativeImputer) |
+| miceforest | chained equations | no | no | no |
+| HyperImpute | AutoML | no | no | yes (Jarrett et al. 2022) |
+| GAIN | generative | no | no | yes (Yoon et al. 2018) |
+| MinProb, QRILC | left-censored | no | no | yes (Lazar et al. 2016) |
+| **MICE-Long** | longitudinal chained | yes | yes | new in MIPY |
+| **MICE-LongMNAR** | selection-model MNAR | yes | yes | new in MIPY |
+| softImpute-MI, missForest-MI, miceforest-MI | MI versions | yes | no | new in MIPY |
+
+* **MICE-Long**: chained equations that use each patient's previous visit,
+  next visit and own mean, with a patient-level bootstrap (proper multiple
+  imputation).
+* **MICE-LongMNAR**: the same with selection-model draws for values lost
+  below a detection limit; `settings={"gamma": ...}` sets the sensitivity
+  parameter.
+* softImpute, missForest, mice's `norm.boot` and imputeLCMD's MinProb and
+  QRILC are implemented in Python and checked against the R packages
+  (identical parameters; cell-level agreement r > 0.99 for softImpute).
+
+## Lower-level functions
+
+```python
+done  = mipy.impute(df, method="softImpute", id_col="Patient_ID", time_col="sampling_point", log2=True)
+draws = mipy.impute(df, method="MICE-Long", id_col="Patient_ID", time_col="sampling_point", m=5, log2=True)
+bench = mipy.benchmark(df, methods=["Mean", "softImpute", "MICE-Long"], id_col="Patient_ID",
+                       time_col="sampling_point", log2=True, mechanisms=("MCAR", "MNAR"), repeats=3)
+
+from mipy.mi import pool_estimates      # Rubin's rules over the m completions
+pooled = pool_estimates(estimates, by="term")   # columns: draw, term, beta, se
+```
+
+`mipy.list_methods()` lists every method with the function it calls and its
+evidence; `mipy.literature()` lists 14 Python imputation packages and the
+publication behind each.
+
+## Reproducing the MIPY paper
+
+`notebooks/MIPY_v2_pipeline.ipynb` runs the full GSE65622 analysis of the
+paper (all methods, multiple imputation, MNAR sensitivity, agreement with R,
+data handling up to millions of patients, a synthetic second cohort, the
+survival screen) and writes every number, table and figure.
+
+## Tests
+
+```bash
+pip install "mipy-impute[all,test]"
+pytest
+```
+
+## Citation
+
+See [CITATION.cff](https://github.com/neelesh2302-creator/mipy/blob/main/CITATION.cff).
+If you use MIPY, please cite the MIPY paper and the publication of each method
+you report (`mipy.list_methods()` gives the reference key).
+
+## Licence
+
+MIT

mipy_impute-2.1.0/docs/benchmarking.md

@@ -0,0 +1,18 @@
+# Benchmarking
+
+`mipy.benchmark()` hides a share of the observed values, imputes them with each
+method and scores the hidden values:
+
+* **nRMSE** within each column (RMSE / SD of the true values; 1 = the column's
+  own mean), summarised by the median across columns. Pooling cells across
+  columns inflates correlations (a constant imputer reaches r > 0.9), so all
+  scores are within-column.
+* **Within-patient SD ratio**: pooled within-patient SD of the completed values
+  over that of the true values (1 = preserved, < 1 flattened, > 1 inflated).
+* **Coverage** (multiple imputation): share of hidden values inside the 95%
+  interval formed from the completions.
+
+Masking designs (`mipy.masking.Amputer`): MCAR; MAR (driven by visit, clinical
+covariates and the sample's mean level); MNAR (logistic in the cell's own
+value, slope `strength`); LOD (hard detection limit). Every column keeps at
+least `min_obs` observed values.

mipy_impute-2.1.0/docs/command_line.md

@@ -0,0 +1,37 @@
+# Command line
+
+Installing MIPY adds the command `mipy` (also available as `python -m mipy`).
+
+```bash
+mipy example example.csv                 # write the example cohort
+mipy check my_data.csv                   # how MIPY reads the table; nothing imputed
+mipy analyze my_data.csv --out results   # benchmark, impute, figures, report
+mipy impute my_data.csv --method MICE-Long --m 5   # one method, no benchmark
+mipy methods                             # the methods and their evidence
+mipy --version
+```
+
+## mipy analyze
+
+```
+mipy analyze DATA [--id COL] [--time COL] [--features A,B | first:last]
+                  [--clinical A,B | none] [--survival TIME EVENT | --no-survival]
+                  [--out DIR] [--methods quick|standard|complete|all|A,B]
+                  [--mechanisms MCAR,MAR,MNAR,LOD] [--repeats 3] [--rate 0.2]
+                  [--strength 2] [--m 5] [--export auto|METHOD|none]
+                  [--workers 1|auto] [--seed 2026] [--log2 auto|yes|no]
+                  [--max-missing 0.9] [--sheet NAME] [--layout wide|long
+                  --feature-col COL --value-col COL] [--fresh] [--open] [--quiet]
+```
+
+Example with the columns of the GSE65622 analysis files:
+
+```bash
+mipy analyze RFS_data.csv --id Patient_ID --time sampling_point --survival RFS event --out RFS_results --open
+```
+
+On Windows, a path with spaces needs quotes: `mipy analyze "C:\My data\cohort.xlsx"`.
+
+The command prints each step, and at the end the best method per mechanism and
+the path of the report. Errors in the input (a missing file or column) are
+printed as one line starting with `mipy:`, with exit code 2.

mipy_impute-2.1.0/docs/getting_started.md

@@ -0,0 +1,43 @@
+# Getting started
+
+## The one-call route
+
+```python
+import mipy
+
+df = mipy.example_cohort()                 # or pd.read_csv("my_data.csv"), or a file path
+res = mipy.analyze(df, out="example_results", methods="quick", repeats=1)
+res.show()                                 # inline in Jupyter; text and file paths elsewhere
+res.decision                               # best method under each mechanism
+res.completed                              # the completed table
+```
+
+`notebooks/quickstart.ipynb` shows the output, figures included. See
+[your_data.md](your_data.md) for the table layout and every option.
+
+## Step by step, with simulated data
+
+```python
+import mipy
+from mipy.datasets import simulate_longitudinal
+from mipy.masking import Amputer
+
+sim = simulate_longitudinal(n_patients=100, n_proteins=80, seed=1)
+X, patient, time = sim["X"], sim["patient"], sim["time"]
+
+amp = Amputer(X, time=time, rate=0.2).ampute("MNAR", seed=7)
+ctx = mipy.ImputeContext(patient=patient, time=time,
+                         schema=mipy.build_variable_schema(amp["X"]))
+for name in ["Mean", "softImpute", "MICE-Long", "MICE-LongMNAR"]:
+    out, draws = mipy.run(name, amp["X"], ctx)
+    print(name, mipy.evaluate(X, out, amp["mask"], patient=patient))
+```
+
+With a data frame (rows = patient-visits):
+
+```python
+done = mipy.impute(df, method="MICE-Long", id_col="Patient_ID",
+                   time_col="sampling_point", log2=True)
+```
+
+The notebook `notebooks/getting_started.ipynb` runs these steps with output.