melite 0.2.0__tar.gz → 0.2.2__tar.gz

{melite-0.2.0 → melite-0.2.2}/CHANGELOG.md

@@ -7,6 +7,44 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ---
 
+## [v0.2.2] - 2026-05-28
+
+### Changed
+- SVC is now trained as a `StandardScaler` -> `SVC` sklearn `Pipeline`.
+- Scaling is applied only to SVC; `RandomForestClassifier` and
+  `XGBClassifier` remain unscaled direct estimators.
+- The full SVC search grid now includes a linear kernel with `svc__C` values
+  `[0.01, 0.1, 1, 10]`.
+- Exported SVC models now preserve the same `StandardScaler` -> `SVC`
+  pipeline used during benchmarking.
+
+### Compatibility
+- Legacy export compatibility is preserved for older SVC parameter
+  dictionaries that use unprefixed keys such as `C` and `kernel` instead of
+  pipeline keys such as `svc__C` and `svc__kernel`.
+
+---
+
+## [v0.2.1] - 2026-05-27
+
+### Changed
+- `[models].active` / `ACTIVE_MODELS` now controls which model families are
+  trained during benchmarking.
+- `melite export` now uses strict dataset loading for registry-based datasets
+  and no longer falls back to `arr.files[0]` when an `.npz` file lacks `X`.
+- Added an installed-wheel smoke test that builds the wheel, installs it
+  outside the repository checkout, runs a toy `[datasets.toy]` smoke benchmark,
+  exports row 0 non-interactively, and verifies generated artifacts.
+
+### Compatibility
+- The top-level public API remains unchanged:
+  `Config`, `load_datasets`, `plot_cv_distributions`, `predict`, and
+  `__version__`.
+- Legacy `reduction_type` + `level` export rows remain supported, but
+  individual legacy `.npz` files must now contain an explicit `X` array.
+
+---
+
 ## [v0.2.0] - 2026-05-26
 
 ### Added

{melite-0.2.0 → melite-0.2.2}/CITATION.cff

@@ -2,8 +2,8 @@ cff-version: 1.2.0
 message: "If you use this software, please cite it as below."
 type: software
 title: "MELITE: Multi-model Evaluation and Learning for Inference-ready Tabular Experiments"
-version: "0.2.0"
-date-released: "2026-05-26"
+version: "0.2.2"
+date-released: "2026-05-28"
 authors:
   - family-names: "Contreras-Torres"
     given-names: "Flavio F."

{melite-0.2.0 → melite-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: melite
-Version: 0.2.0
+Version: 0.2.2
 Summary: Tabular classification benchmarking toolkit for model selection, repeated stratified cross-validation, final model export, and artifact-based inference.
 Project-URL: Homepage, https://github.com/NanoBiostructuresRG/melite
 Project-URL: Repository, https://github.com/NanoBiostructuresRG/melite
@@ -28,6 +28,7 @@ Requires-Dist: scikit-learn>=1.2
 Requires-Dist: xgboost>=1.7
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: hatchling>=1.18; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: twine>=4.0; extra == 'dev'
 Provides-Extra: docs
@@ -40,7 +41,7 @@ Description-Content-Type: text/markdown
 
 [![CI](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml/badge.svg)](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml)
 [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-v0.1.11-blue.svg)]()
+[![Version](https://img.shields.io/badge/version-v0.2.2-blue.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)]()
 
 **MELITE** is a pre-stable Python toolkit for tabular classification
@@ -59,7 +60,7 @@ Project: MELITE
 PyPI distribution: melite
 Import package: melite
 CLI: melite
-Version: 0.2.0
+Version: 0.2.2
 License: LGPL-3.0-or-later
 Status: alpha / pre-stable
 ```
@@ -171,6 +172,19 @@ Registered datasets are loaded strictly: missing files, missing `X`, non-2D or
 non-numeric `X`, length mismatches, and embedded `y` mismatches fail the run.
 Legacy `[benchmark].reduction_types` and `levels` configs are still accepted
 and are normalized into equivalent dataset entries such as `PCA70` and `UMAP90`.
+
+Model families are controlled by `[models].active`:
+
+```toml
+[models]
+active = ["svc", "rf", "xgb"]
+```
+
+Remove a key to skip that family during training. Valid keys are `svc`, `rf`,
+and `xgb`.
+
+SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn pipeline.
+Random Forest and XGBoost are trained as unscaled estimators.
     
 ## CLI
 
@@ -203,7 +217,7 @@ from melite import __version__
 ```
 
 Modules not listed above are importable directly but are not part of the public
-contract and may change before 0.2.0.
+contract and may change before 1.0.
 
 ## Input Format
 
@@ -234,13 +248,14 @@ Local inputs and generated artifacts such as `raw/`, `data/`, `output/`,
 
 ## Validation
 
-The current `dev/v0.2.0` branch targets:
+The current `dev/v0.2.2` branch targets:
 
 ```bash
 python -m pytest tests/ -v --basetemp=.review_pytest_tmp -o cache_dir=.review_pytest_cache
 mkdocs build --strict
-python -m build
+python -m build --no-isolation
 python -m twine check dist/*
+python scripts/smoke_install_wheel.py
 melite --help
 melite run --help
 melite export --help
@@ -253,20 +268,14 @@ If you use MELITE in your research, please cite it using the metadata in
 [CITATION.cff](CITATION.cff).
 
 ```text
-Contreras-Torres, F. F., & Murrieta, A. C. (2026). MELITE: Multi-model
-Evaluation and Learning for Inference-ready Tabular Experiments (0.1.11).
-Tecnologico de Monterrey. https://github.com/NanoBiostructuresRG/melite
+Contreras-Torres, F. F., & Murrieta, A. C. (2026). MELITE: Multi-model Evaluation and Learning for Inference-ready Tabular Experiments. Zenodo. https://doi.org/10.5281/zenodo.20382752
 ```
 
 ## Authors
 
-Developed by **Flavio F. Contreras-Torres**
-
-Tecnologico de Monterrey
-
-Co-author: **Ana C. Murrieta**
+Developed by **Flavio F. Contreras-Torres**. Tecnologico de Monterrey
 
-Tecnologico de Monterrey
+Co-author: **Ana C. Murrieta**. Tecnologico de Monterrey
 
 ## License
 

{melite-0.2.0 → melite-0.2.2}/README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml/badge.svg)](https://github.com/NanoBiostructuresRG/melite/actions/workflows/ci.yml)
 [![License: LGPL v3](https://img.shields.io/badge/License-LGPL_v3-blue.svg)](LICENSE)
-[![Version](https://img.shields.io/badge/version-v0.1.11-blue.svg)]()
+[![Version](https://img.shields.io/badge/version-v0.2.2-blue.svg)]()
 [![Python](https://img.shields.io/badge/python-3.11%20%7C%203.12-blue)]()
 
 **MELITE** is a pre-stable Python toolkit for tabular classification
@@ -21,7 +21,7 @@ Project: MELITE
 PyPI distribution: melite
 Import package: melite
 CLI: melite
-Version: 0.2.0
+Version: 0.2.2
 License: LGPL-3.0-or-later
 Status: alpha / pre-stable
 ```
@@ -133,6 +133,19 @@ Registered datasets are loaded strictly: missing files, missing `X`, non-2D or
 non-numeric `X`, length mismatches, and embedded `y` mismatches fail the run.
 Legacy `[benchmark].reduction_types` and `levels` configs are still accepted
 and are normalized into equivalent dataset entries such as `PCA70` and `UMAP90`.
+
+Model families are controlled by `[models].active`:
+
+```toml
+[models]
+active = ["svc", "rf", "xgb"]
+```
+
+Remove a key to skip that family during training. Valid keys are `svc`, `rf`,
+and `xgb`.
+
+SVC is trained and exported as a `StandardScaler` -> `SVC` sklearn pipeline.
+Random Forest and XGBoost are trained as unscaled estimators.
     
 ## CLI
 
@@ -165,7 +178,7 @@ from melite import __version__
 ```
 
 Modules not listed above are importable directly but are not part of the public
-contract and may change before 0.2.0.
+contract and may change before 1.0.
 
 ## Input Format
 
@@ -196,13 +209,14 @@ Local inputs and generated artifacts such as `raw/`, `data/`, `output/`,
 
 ## Validation
 
-The current `dev/v0.2.0` branch targets:
+The current `dev/v0.2.2` branch targets:
 
 ```bash
 python -m pytest tests/ -v --basetemp=.review_pytest_tmp -o cache_dir=.review_pytest_cache
 mkdocs build --strict
-python -m build
+python -m build --no-isolation
 python -m twine check dist/*
+python scripts/smoke_install_wheel.py
 melite --help
 melite run --help
 melite export --help
@@ -215,20 +229,14 @@ If you use MELITE in your research, please cite it using the metadata in
 [CITATION.cff](CITATION.cff).
 
 ```text
-Contreras-Torres, F. F., & Murrieta, A. C. (2026). MELITE: Multi-model
-Evaluation and Learning for Inference-ready Tabular Experiments (0.1.11).
-Tecnologico de Monterrey. https://github.com/NanoBiostructuresRG/melite
+Contreras-Torres, F. F., & Murrieta, A. C. (2026). MELITE: Multi-model Evaluation and Learning for Inference-ready Tabular Experiments. Zenodo. https://doi.org/10.5281/zenodo.20382752
 ```
 
 ## Authors
 
-Developed by **Flavio F. Contreras-Torres**
-
-Tecnologico de Monterrey
-
-Co-author: **Ana C. Murrieta**
+Developed by **Flavio F. Contreras-Torres**. Tecnologico de Monterrey
 
-Tecnologico de Monterrey
+Co-author: **Ana C. Murrieta**. Tecnologico de Monterrey
 
 ## License
 

{melite-0.2.0 → melite-0.2.2}/melite/config.py

@@ -197,8 +197,8 @@ class Config:
             return [
                 {
                     "model": ["svc"],
-                    "kernel": ["linear"],
-                    "C": [1],
+                    "svc__kernel": ["linear"],
+                    "svc__C": [1],
                 },
                 {
                     "model": ["rf"],
@@ -223,17 +223,22 @@ class Config:
         return [
             {
                 "model": ["svc"],
-                "kernel": ["poly"],
-                "C": [0.01, 0.1, 1, 10],
-                "coef0": [0.0, 0.1, 0.02, 0.6, 0.8, 1],
-                "gamma": [0.001, 0.002, 0.004, 0.008, 0.01, 0.02, 0.04, 0.08, 0.1, 0.2],
-                "degree": [3, 4, 5],
+                "svc__kernel": ["linear"],
+                "svc__C": [0.01, 0.1, 1, 10],
             },
             {
                 "model": ["svc"],
-                "kernel": ["rbf"],
-                "C": [0.01, 0.02, 0.1, 0.2, 1, 2, 10, 20],
-                "gamma": [0.001, 0.002, 0.004, 0.008, 0.01, 0.02, 0.04, 0.08, 0.1, 0.2],
+                "svc__kernel": ["poly"],
+                "svc__C": [0.01, 0.1, 1, 10],
+                "svc__coef0": [0.0, 0.1, 0.2, 0.6, 0.8, 1],
+                "svc__gamma": [0.001, 0.002, 0.004, 0.008, 0.01, 0.02, 0.04, 0.08, 0.1, 0.2],
+                "svc__degree": [3, 4, 5],
+            },
+            {
+                "model": ["svc"],
+                "svc__kernel": ["rbf"],
+                "svc__C": [0.01, 0.02, 0.1, 0.2, 1, 2, 10, 20],
+                "svc__gamma": [0.001, 0.002, 0.004, 0.008, 0.01, 0.02, 0.04, 0.08, 0.1, 0.2],
             },
             {
                 "model": ["rf"],

{melite-0.2.0 → melite-0.2.2}/melite/export_best_model.py

@@ -20,10 +20,12 @@ import joblib
 import numpy as np
 import pandas as pd
 from .config import Config
-from .load_dataset import _load_one_dataset
+from .load_dataset import load_datasets, _load_one_dataset
 from .plot_metrics import plot_cv_distributions
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.model_selection import cross_validate, RepeatedStratifiedKFold
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.preprocessing import StandardScaler
 from sklearn.svm import SVC
 from xgboost import XGBClassifier
 
@@ -32,7 +34,6 @@ __all__ = ["Finalizer"]
 logger = logging.getLogger(__name__)
 
 MODEL_MAP = {
-    "SVC": SVC,
     "RandomForestClassifier": RandomForestClassifier,
     "XGBClassifier": XGBClassifier,
 }
@@ -70,20 +71,19 @@ class DatasetLoader:
     def load_row(self, row: pd.Series) -> Tuple[np.ndarray, np.ndarray]:
         """Load the dataset referenced by a result row.
 
-        New v0.2.0 result rows are resolved by their ``dataset`` id in
+        Dataset-registry result rows are resolved by their ``dataset`` id in
         ``cfg.DATASETS``. Older result rows without ``dataset`` fall back to
         the legacy ``reduction_type`` + ``level`` lookup.
         """
         if "dataset" in row and _has_value(row.get("dataset")):
             dataset_id = str(row.get("dataset"))
             try:
-                spec = self._cfg.DATASETS[dataset_id]
+                dataset = load_datasets(self._cfg)[dataset_id]
             except KeyError as exc:
                 raise KeyError(
                     f"Dataset '{dataset_id}' from results.csv is not registered "
                     "in cfg.DATASETS."
                 ) from exc
-            dataset = _load_one_dataset(dataset_id, spec)
             return dataset["X"], dataset["y"]
 
         return self.load(row.reduction_type, int(row.level))
@@ -129,9 +129,19 @@ class DatasetLoader:
         fp = self._data_root / f"{reduction}{level}.npz"
         if not fp.exists():
             return None
-        arr = np.load(fp)
-        self._ensure_labels()
-        return arr["X"] if "X" in arr.files else arr[arr.files[0]]
+        dataset_id = f"{reduction}{level}"
+        spec = {
+            "path": fp,
+            "label_path": Path(self._cfg.PATHS["INPUT"]) / "labels.npy",
+            "metadata": {
+                "family": "dimensionality",
+                "method": reduction,
+                "level": level,
+            },
+        }
+        dataset = _load_one_dataset(dataset_id, spec)
+        self._labels = dataset["y"]
+        return dataset["X"]
 
     def _try_aggregated_file(self, reduction: str, level: int) -> np.ndarray | None:
         fp = self._data_root / f"{reduction}s.npz"
@@ -142,7 +152,23 @@ class DatasetLoader:
             key = pattern.format(rtype=reduction, lvl=level)
             if key in arr:
                 self._ensure_labels()
-                return arr[key]
+                X = arr[key]
+                if X.ndim != 2:
+                    raise ValueError(
+                        f"Legacy dataset '{reduction}{level}' X must be 2D; "
+                        f"got shape {X.shape}."
+                    )
+                if not np.issubdtype(X.dtype, np.number):
+                    raise ValueError(
+                        f"Legacy dataset '{reduction}{level}' X must be numeric; "
+                        f"got dtype {X.dtype}."
+                    )
+                if len(self._labels) != X.shape[0]:
+                    raise ValueError(
+                        f"Legacy dataset '{reduction}{level}' X/y length mismatch: "
+                        f"X has {X.shape[0]} rows, y has {len(self._labels)} labels."
+                    )
+                return X
         raise KeyError(f"Level {level} not found inside {fp.name}.")
 
     def _ensure_labels(self) -> None:
@@ -307,7 +333,16 @@ class Finalizer:
     def _build_model(name: str, serialised_params: str) -> Any:
         params = ast.literal_eval(serialised_params)
         if name == "SVC":
-            params = {**params, "probability": True}
+            model = SklearnPipeline([
+                ("scaler", StandardScaler()),
+                ("svc", SVC()),
+            ])
+            svc_params = {
+                key if "__" in key else f"svc__{key}": value
+                for key, value in params.items()
+            }
+            svc_params.setdefault("svc__probability", True)
+            return model.set_params(**svc_params)
         try:
             return MODEL_MAP[name](**params)
         except KeyError as exc:

{melite-0.2.0 → melite-0.2.2}/melite/main.py

@@ -10,6 +10,8 @@ import logging
 from pathlib import Path
 
 import numpy as np
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.svm import SVC
 
 from .config import Config
 from .load_dataset import load_datasets
@@ -103,6 +105,12 @@ class Main:
             return method
         return None
 
+    @staticmethod
+    def _model_name(model):
+        if isinstance(model, SklearnPipeline) and isinstance(model.steps[-1][1], SVC):
+            return "SVC"
+        return model.__class__.__name__
+
     def run(self) -> None:
         """Execute the benchmarking pipeline for all configured datasets.
 
@@ -145,7 +153,7 @@ class Main:
             ) = self.pipeline.run(X_train, y_train, reduction_type or dataset_id, level)
 
             params = self._clean_params(best_params)
-            model_name = best_model.__class__.__name__
+            model_name = self._model_name(best_model)
 
             metadata_lines = [
                 f"Family: {family}" if family is not None else None,

{melite-0.2.0 → melite-0.2.2}/melite/model_training.py

@@ -13,6 +13,8 @@ from abc import ABC, abstractmethod
 import numpy as np
 from sklearn.ensemble import RandomForestClassifier
 from sklearn.model_selection import GridSearchCV, RepeatedStratifiedKFold, cross_validate
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.preprocessing import StandardScaler
 from sklearn.svm import SVC
 from xgboost import XGBClassifier
 
@@ -82,10 +84,30 @@ class MultiModelTrainer(ModelTrainer):
         rs = getattr(self.config, "RANDOM_STATE", 42)
 
         self.model_builders = {
-            "svc": lambda: SVC(probability=True, random_state=rs),
+            "svc": lambda: SklearnPipeline([
+                ("scaler", StandardScaler()),
+                ("svc", SVC(probability=True, random_state=rs)),
+            ]),
             "rf": lambda: RandomForestClassifier(random_state=rs, n_jobs=-1),
             "xgb": lambda: XGBClassifier(eval_metric="logloss", random_state=rs, n_jobs=-1),
         }
+        self.active_models = self._validate_active_models()
+
+    def _validate_active_models(self):
+        active_models = getattr(self.config, "ACTIVE_MODELS", list(self.model_builders))
+        if not active_models:
+            raise ValueError("ACTIVE_MODELS must contain at least one model key.")
+
+        unknown = [model for model in active_models if model not in self.model_builders]
+        if unknown:
+            unknown_models = ", ".join(unknown)
+            valid_models = ", ".join(self.model_builders)
+            raise ValueError(
+                f"Unknown active model(s): {unknown_models}. "
+                f"Valid model keys are: {valid_models}."
+            )
+
+        return list(active_models)
 
     def _build_cv_strategy(self):
         cv_cfg = self.config.get_cv_config()
@@ -169,7 +191,7 @@ class MultiModelTrainer(ModelTrainer):
     def train_and_select_best_model(self, X_train, y_train, reduction_type, level):
         """Train all active models and return the best configuration.
 
-        For each model key in ``model_builders``, runs grid search followed by
+        For each configured active model key, runs grid search followed by
         cross-validation. The model with the highest mean F1-macro is selected.
 
         Parameters
@@ -209,7 +231,7 @@ class MultiModelTrainer(ModelTrainer):
             "auc": None, "auc_std": None,
         }
 
-        for model_name in self.model_builders:
+        for model_name in self.active_models:
             model = self.model_builders[model_name]()
             param_grid = self._filter_param_grid(model_name)
             tuned_model, params = self.perform_grid_search(model, X_train, y_train, param_grid)

{melite-0.2.0 → melite-0.2.2}/melite/version.py

@@ -6,7 +6,7 @@ It is read by ``hatchling`` at build time via ``[tool.hatch.version]``
 and imported by ``result_manager`` to stamp generated reports.
 """
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 PROJECT_NAME = "MELITE"
 PROJECT_VERSION = __version__
 PROJECT_STATUS = "alpha"

{melite-0.2.0 → melite-0.2.2}/pyproject.toml

@@ -50,6 +50,7 @@ dependencies = [
 dev = [
     "pytest>=7.0",
     "build>=1.0",
+    "hatchling>=1.18",
     "twine>=4.0",
 ]
 docs = [

melite-0.2.2/scripts/smoke_install_wheel.py

@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+"""Installed-wheel smoke test for the MELITE toy dataset workflow.
+
+The script builds a wheel from the current checkout, installs it into a
+temporary virtual environment, creates a tiny strict ``[datasets.toy]``
+configuration outside the repository, runs ``melite run --smoke``, exports row
+0 non-interactively, and verifies the expected artifacts.
+"""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import numpy as np
+
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+EXPECTED_API = [
+    "Config",
+    "load_datasets",
+    "plot_cv_distributions",
+    "predict",
+    "__version__",
+]
+
+
+def _run(cmd: list[str | Path], *, cwd: Path, env: dict[str, str] | None = None) -> None:
+    display = " ".join(str(part) for part in cmd)
+    print(f"[smoke] {display}")
+    subprocess.run([str(part) for part in cmd], cwd=cwd, env=env, check=True)
+
+
+def _venv_python(venv_dir: Path) -> Path:
+    if os.name == "nt":
+        return venv_dir / "Scripts" / "python.exe"
+    return venv_dir / "bin" / "python"
+
+
+def _venv_melite(venv_dir: Path) -> Path:
+    if os.name == "nt":
+        return venv_dir / "Scripts" / "melite.exe"
+    return venv_dir / "bin" / "melite"
+
+
+def _build_wheel(dist_dir: Path) -> Path:
+    if dist_dir.exists():
+        shutil.rmtree(dist_dir)
+    _run(
+        [sys.executable, "-m", "build", "--wheel", "--no-isolation", "--outdir", dist_dir],
+        cwd=REPO_ROOT,
+    )
+    wheels = sorted(dist_dir.glob("melite-*.whl"))
+    if len(wheels) != 1:
+        raise RuntimeError(f"Expected exactly one MELITE wheel in {dist_dir}, got {wheels}")
+    return wheels[0]
+
+
+def _write_toy_project(work_dir: Path) -> Path:
+    raw_dir = work_dir / "raw"
+    data_dir = work_dir / "data"
+    output_dir = work_dir / "output"
+    raw_dir.mkdir()
+    data_dir.mkdir()
+    output_dir.mkdir()
+
+    X = np.array([
+        [0.0, 0.1, 1.0],
+        [0.1, 0.0, 0.9],
+        [0.2, 0.1, 1.1],
+        [0.1, 0.2, 1.0],
+        [0.2, 0.0, 0.8],
+        [0.0, 0.2, 1.2],
+        [1.0, 1.1, 0.0],
+        [1.1, 1.0, 0.1],
+        [0.9, 1.2, 0.0],
+        [1.2, 0.9, 0.2],
+        [1.0, 1.0, 0.0],
+        [1.1, 1.2, 0.1],
+    ], dtype=float)
+    y = np.array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1], dtype=np.int64)
+
+    label_path = raw_dir / "labels.npy"
+    dataset_path = data_dir / "toy.npz"
+    np.save(label_path, y)
+    np.savez(dataset_path, X=X, y=y)
+
+    config_path = work_dir / "toy_config.toml"
+    config_path.write_text(
+        f"""
+[paths]
+input = "{raw_dir.as_posix()}/"
+dataset = "{data_dir.as_posix()}/"
+output = "{output_dir.as_posix()}/"
+
+[benchmark]
+random_state = 42
+
+[cv]
+n_splits = 3
+n_repeats = 1
+
+[cv_smoke]
+n_splits = 3
+n_repeats = 1
+
+[models]
+active = ["svc"]
+
+[datasets.toy]
+path = "{dataset_path.as_posix()}"
+label_path = "{label_path.as_posix()}"
+family = "smoke"
+method = "toy"
+description = "Installed wheel smoke dataset"
+""".lstrip(),
+        encoding="utf-8",
+    )
+    return config_path
+
+
+def _check_imports(python: Path) -> None:
+    code = f"""
+import pathlib
+import melite
+expected = {EXPECTED_API!r}
+assert melite.__all__ == expected, melite.__all__
+for name in expected:
+    assert hasattr(melite, name), f"{{name}} missing"
+assert 'load_dataset' not in melite.__all__
+assert 'ResultManager' not in melite.__all__
+repo = pathlib.Path({str(REPO_ROOT)!r}).resolve()
+module_path = pathlib.Path(melite.__file__).resolve()
+assert repo not in module_path.parents, module_path
+print(melite.__version__, module_path)
+"""
+    _run([python, "-c", code], cwd=REPO_ROOT.parent)
+
+
+def _verify_outputs(work_dir: Path) -> None:
+    output_dir = work_dir / "output"
+    results_csv = output_dir / "results.csv"
+    model_path = output_dir / "Model_SVC_toy.pkl"
+    figure_path = output_dir / "figures" / "SVC_toy.png"
+
+    for path in (results_csv, model_path, figure_path):
+        if not path.exists():
+            raise AssertionError(f"Expected artifact was not created: {path}")
+
+    with open(results_csv, newline="", encoding="utf-8") as f:
+        rows = list(csv.DictReader(f))
+    if len(rows) != 1:
+        raise AssertionError(f"Expected one result row, got {len(rows)}")
+    row = rows[0]
+    if row["dataset"] != "toy":
+        raise AssertionError(f"Expected dataset 'toy', got {row['dataset']!r}")
+    if row["model_name"] != "SVC":
+        raise AssertionError(f"Expected model 'SVC', got {row['model_name']!r}")
+    if row["smoke"] != "True":
+        raise AssertionError(f"Expected smoke=True row, got {row['smoke']!r}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--keep-temp",
+        action="store_true",
+        help="Keep the temporary smoke directory for debugging.",
+    )
+    args = parser.parse_args()
+
+    temp_root = Path(tempfile.mkdtemp(prefix="melite-wheel-smoke-")).resolve()
+    print(f"[smoke] temp root: {temp_root}")
+    try:
+        wheel = _build_wheel(temp_root / "dist")
+        venv_dir = temp_root / "venv"
+        work_dir = temp_root / "work"
+        work_dir.mkdir()
+
+        _run([sys.executable, "-m", "venv", "--system-site-packages", venv_dir], cwd=temp_root)
+        python = _venv_python(venv_dir)
+        melite = _venv_melite(venv_dir)
+
+        _run([python, "-m", "pip", "install", "--no-deps", wheel], cwd=temp_root)
+        _check_imports(python)
+
+        config_path = _write_toy_project(work_dir)
+        _run([melite, "run", "--config", config_path, "--smoke"], cwd=work_dir)
+        _run(
+            [
+                melite,
+                "export",
+                "--config",
+                config_path,
+                "--row",
+                "0",
+                "--csv",
+                work_dir / "output" / "results.csv",
+                "--outdir",
+                work_dir / "output",
+                "--force",
+            ],
+            cwd=work_dir,
+        )
+        _verify_outputs(work_dir)
+        print("[smoke] installed-wheel toy workflow passed")
+    finally:
+        if args.keep_temp:
+            print(f"[smoke] kept temp root: {temp_root}")
+        else:
+            shutil.rmtree(temp_root, ignore_errors=True)
+
+
+if __name__ == "__main__":
+    main()

{melite-0.2.0 → melite-0.2.2}/tests/test_config.py

@@ -48,6 +48,51 @@ def test_config_smoke_false_uses_full_grids():
     assert has_multiple
 
 
+def test_config_svc_grid_uses_pipeline_parameter_names():
+    cfg = Config()
+    svc_entries = [
+        entry for entry in cfg.PARAM_GRID
+        if entry["model"] == ["svc"]
+    ]
+
+    assert svc_entries
+    for entry in svc_entries:
+        assert "C" not in entry
+        assert "kernel" not in entry
+        assert "gamma" not in entry
+        assert "svc__C" in entry
+        assert "svc__kernel" in entry
+
+
+def test_config_full_svc_grid_includes_linear_kernel_without_unused_params():
+    cfg = Config()
+
+    linear_entries = [
+        entry for entry in cfg.PARAM_GRID
+        if entry["model"] == ["svc"] and entry["svc__kernel"] == ["linear"]
+    ]
+
+    assert linear_entries == [{
+        "model": ["svc"],
+        "svc__kernel": ["linear"],
+        "svc__C": [0.01, 0.1, 1, 10],
+    }]
+    assert "svc__gamma" not in linear_entries[0]
+    assert "svc__degree" not in linear_entries[0]
+    assert "svc__coef0" not in linear_entries[0]
+
+
+def test_config_smoke_svc_grid_uses_pipeline_parameter_names():
+    cfg = Config(smoke=True)
+    svc_entry = next(
+        entry for entry in cfg.PARAM_GRID
+        if entry["model"] == ["svc"]
+    )
+
+    assert svc_entry["svc__kernel"] == ["linear"]
+    assert svc_entry["svc__C"] == [1]
+
+
 def test_config_setup_creates_directories(tmp_path):
     cfg = Config()
     cfg.PATHS = {

{melite-0.2.0 → melite-0.2.2}/tests/test_export.py

@@ -3,11 +3,15 @@
 
 import csv
 
+import joblib
 import numpy as np
 import pytest
 
 from melite.config import Config
 from melite.export_best_model import Finalizer
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVC
 
 
 class DummyModel:
@@ -44,6 +48,14 @@ def _write_npz(tmp_path, name, X, y):
     return path
 
 
+def _write_npz_without_X(tmp_path, name, Z):
+    data_dir = tmp_path / "data"
+    data_dir.mkdir(exist_ok=True)
+    path = data_dir / f"{name}.npz"
+    np.savez(path, Z=Z)
+    return path
+
+
 def _write_results_csv(path, fieldnames, row):
     path.parent.mkdir(exist_ok=True)
     with open(path, "w", newline="", encoding="utf-8") as f:
@@ -137,7 +149,7 @@ def test_export_dataset_row_uses_dataset_id_for_artifact(monkeypatch, tmp_path):
             "description": "",
             "reduction_type": "",
             "model_name": "SVC",
-            "parameters": "{'kernel': 'linear', 'C': 1}",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
             "f1_macro": 0.8,
             "accuracy": 0.8,
             "auc_roc": 0.9,
@@ -152,7 +164,81 @@ def test_export_dataset_row_uses_dataset_id_for_artifact(monkeypatch, tmp_path):
     assert (tmp_path / "output" / "Model_SVC_morgan_r2_2048.pkl").exists()
 
 
-def test_export_legacy_row_falls_back_to_reduction_and_level(monkeypatch, tmp_path):
+def test_export_dataset_row_uses_strict_load_datasets(monkeypatch, tmp_path):
+    import melite.export_best_model as export_module
+
+    label_path, y = _write_labels(tmp_path)
+    cfg = _make_config(tmp_path)
+    cfg.DATASETS = {
+        "maccs": {
+            "path": str(tmp_path / "data" / "maccs.npz"),
+            "label_path": str(label_path),
+            "metadata": {"family": "fingerprints", "method": "MACCS"},
+        }
+    }
+    csv_path = tmp_path / "output" / "results.csv"
+    _write_results_csv(
+        csv_path,
+        ["dataset", "model_name", "parameters", "smoke"],
+        {
+            "dataset": "maccs",
+            "model_name": "SVC",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
+            "smoke": False,
+        },
+    )
+    calls = []
+
+    def fake_load_datasets(config):
+        calls.append(config)
+        return {
+            "maccs": {
+                "X": np.ones((20, 5)),
+                "y": y,
+                "metadata": {"family": "fingerprints", "method": "MACCS"},
+            }
+        }
+
+    monkeypatch.setattr(export_module, "load_datasets", fake_load_datasets)
+    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
+
+    Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
+
+    assert calls == [cfg]
+    assert (tmp_path / "output" / "Model_SVC_maccs.pkl").exists()
+
+
+def test_export_dataset_npz_without_X_fails_clearly(monkeypatch, tmp_path):
+    label_path, _ = _write_labels(tmp_path)
+    dataset_path = _write_npz_without_X(tmp_path, "maccs", np.ones((20, 5)))
+    cfg = _make_config(tmp_path)
+    cfg.DATASETS = {
+        "maccs": {
+            "path": str(dataset_path),
+            "label_path": str(label_path),
+            "metadata": {"family": "fingerprints", "method": "MACCS"},
+        }
+    }
+    csv_path = tmp_path / "output" / "results.csv"
+    _write_results_csv(
+        csv_path,
+        ["dataset", "model_name", "parameters", "smoke"],
+        {
+            "dataset": "maccs",
+            "model_name": "SVC",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
+            "smoke": False,
+        },
+    )
+    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
+
+    with pytest.raises(ValueError, match="Required key 'X' not found"):
+        Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
+
+
+def test_export_legacy_row_with_valid_X_and_labels_succeeds(monkeypatch, tmp_path):
     _, y = _write_labels(tmp_path)
     _write_npz(tmp_path, "PCA70", np.ones((20, 5)), y)
     cfg = _make_config(tmp_path)
@@ -167,7 +253,7 @@ def test_export_legacy_row_falls_back_to_reduction_and_level(monkeypatch, tmp_pa
             "reduction_type": "PCA",
             "level": 70,
             "model_name": "SVC",
-            "parameters": "{'kernel': 'linear', 'C': 1}",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
             "f1_macro": 0.8,
             "accuracy": 0.8,
             "auc_roc": 0.9,
@@ -182,6 +268,79 @@ def test_export_legacy_row_falls_back_to_reduction_and_level(monkeypatch, tmp_pa
     assert (tmp_path / "output" / "Model_SVC_PCA70.pkl").exists()
 
 
+def test_export_svc_saves_scaler_pipeline(monkeypatch, tmp_path):
+    label_path, y = _write_labels(tmp_path)
+    dataset_path = _write_npz(tmp_path, "toy", np.ones((20, 5)), y)
+    cfg = _make_config(tmp_path)
+    cfg.DATASETS = {
+        "toy": {
+            "path": str(dataset_path),
+            "label_path": str(label_path),
+            "metadata": {"family": "smoke", "method": "toy"},
+        }
+    }
+    csv_path = tmp_path / "output" / "results.csv"
+    _write_results_csv(
+        csv_path,
+        ["dataset", "model_name", "parameters", "smoke"],
+        {
+            "dataset": "toy",
+            "model_name": "SVC",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
+            "smoke": False,
+        },
+    )
+    monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
+
+    Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
+
+    model = joblib.load(tmp_path / "output" / "Model_SVC_toy.pkl")
+    assert isinstance(model, SklearnPipeline)
+    assert list(model.named_steps) == ["scaler", "svc"]
+    assert isinstance(model.named_steps["scaler"], StandardScaler)
+    assert isinstance(model.named_steps["svc"], SVC)
+    assert model.named_steps["svc"].kernel == "linear"
+
+
+def test_export_svc_accepts_legacy_unprefixed_parameters():
+    model = Finalizer._build_model("SVC", "{'kernel': 'linear', 'C': 1}")
+
+    assert isinstance(model, SklearnPipeline)
+    assert model.named_steps["svc"].kernel == "linear"
+    assert model.named_steps["svc"].C == 1
+
+
+def test_export_legacy_npz_without_X_does_not_fallback_to_first_key(
+    monkeypatch, tmp_path
+):
+    _write_labels(tmp_path)
+    _write_npz_without_X(tmp_path, "PCA70", np.ones((20, 5)))
+    cfg = _make_config(tmp_path)
+    csv_path = tmp_path / "output" / "results.csv"
+    _write_results_csv(
+        csv_path,
+        [
+            "reduction_type", "level", "model_name", "parameters",
+            "f1_macro", "accuracy", "auc_roc", "smoke",
+        ],
+        {
+            "reduction_type": "PCA",
+            "level": 70,
+            "model_name": "SVC",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
+            "f1_macro": 0.8,
+            "accuracy": 0.8,
+            "auc_roc": 0.9,
+            "smoke": False,
+        },
+    )
+    monkeypatch.setattr(Finalizer, "_build_model", staticmethod(lambda *_: DummyModel()))
+    monkeypatch.setattr(Finalizer, "_cv_and_plot", lambda *args, **kwargs: None)
+
+    with pytest.raises(ValueError, match="Required key 'X' not found"):
+        Finalizer(csv_path, tmp_path / "output", cfg, row_index=0).run()
+
+
 def test_cv_plot_uses_dataset_id_for_figure(monkeypatch, tmp_path):
     import melite.export_best_model as export_module
 
@@ -193,7 +352,7 @@ def test_cv_plot_uses_dataset_id_for_figure(monkeypatch, tmp_path):
         {
             "dataset": "rdkit_descriptors",
             "model_name": "SVC",
-            "parameters": "{'kernel': 'linear', 'C': 1}",
+            "parameters": "{'svc__kernel': 'linear', 'svc__C': 1}",
             "smoke": False,
         },
     )

melite-0.2.2/tests/test_model_training.py

@@ -0,0 +1,128 @@
+# SPDX-License-Identifier: LGPL-3.0-or-later
+"""Tests for MELITE model training selection behavior."""
+
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVC
+from xgboost import XGBClassifier
+
+from melite.model_training import MultiModelTrainer
+
+
+def _config(active_models):
+    return SimpleNamespace(
+        ACTIVE_MODELS=active_models,
+        RANDOM_STATE=42,
+        PARAM_GRID=[
+            {"model": ["svc"], "svc__C": [1], "svc__kernel": ["linear"]},
+            {"model": ["rf"], "n_estimators": [10]},
+            {"model": ["xgb"], "n_estimators": [10]},
+        ],
+        get_cv_config=lambda: {
+            "n_splits": 2,
+            "n_repeats": 1,
+            "random_state": 42,
+        },
+    )
+
+
+def _trainer_with_fake_training(active_models):
+    trainer = MultiModelTrainer(_config(active_models))
+    trainer.model_builders = {
+        "svc": lambda: "svc-estimator",
+        "rf": lambda: "rf-estimator",
+        "xgb": lambda: "xgb-estimator",
+    }
+    calls = []
+
+    def fake_grid_search(model, X_train, y_train, param_grid):
+        model_name = model.split("-")[0]
+        calls.append((model_name, param_grid))
+        return f"{model_name}-tuned", {"model": model_name}
+
+    def fake_cross_validate(model, X_train, y_train):
+        model_name = model.split("-")[0]
+        scores = {"svc": 0.7, "rf": 0.8, "xgb": 0.6}
+        return scores[model_name], 0.01, 0.75, 0.02, 0.85, 0.03
+
+    trainer.perform_grid_search = fake_grid_search
+    trainer.cross_validate_model = fake_cross_validate
+    return trainer, calls
+
+
+def test_active_models_svc_trains_only_svc():
+    trainer, calls = _trainer_with_fake_training(["svc"])
+
+    result = trainer.train_and_select_best_model(
+        np.ones((4, 2)),
+        np.array([0, 1, 0, 1]),
+        "PCA",
+        70,
+    )
+
+    assert [model_name for model_name, _ in calls] == ["svc"]
+    assert result[0] == "svc-tuned"
+    assert result[1] == {"model": "svc"}
+
+
+def test_active_models_rf_trains_only_rf():
+    trainer, calls = _trainer_with_fake_training(["rf"])
+
+    result = trainer.train_and_select_best_model(
+        np.ones((4, 2)),
+        np.array([0, 1, 0, 1]),
+        "PCA",
+        70,
+    )
+
+    assert [model_name for model_name, _ in calls] == ["rf"]
+    assert result[0] == "rf-tuned"
+    assert result[1] == {"model": "rf"}
+
+
+def test_svc_builder_returns_scaler_then_svc_pipeline():
+    trainer = MultiModelTrainer(_config(["svc"]))
+
+    model = trainer.model_builders["svc"]()
+
+    assert isinstance(model, SklearnPipeline)
+    assert list(model.named_steps) == ["scaler", "svc"]
+    assert isinstance(model.named_steps["scaler"], StandardScaler)
+    assert isinstance(model.named_steps["svc"], SVC)
+    assert model.named_steps["svc"].probability is True
+
+
+def test_rf_and_xgb_builders_remain_unscaled_direct_estimators():
+    trainer = MultiModelTrainer(_config(["rf", "xgb"]))
+
+    rf = trainer.model_builders["rf"]()
+    xgb = trainer.model_builders["xgb"]()
+
+    assert isinstance(rf, RandomForestClassifier)
+    assert isinstance(xgb, XGBClassifier)
+    assert not isinstance(rf, SklearnPipeline)
+    assert not isinstance(xgb, SklearnPipeline)
+
+
+def test_filter_param_grid_preserves_svc_pipeline_prefixes():
+    trainer = MultiModelTrainer(_config(["svc"]))
+
+    grid = trainer._filter_param_grid("svc")
+
+    assert grid == [{"svc__C": [1], "svc__kernel": ["linear"]}]
+
+
+def test_invalid_active_model_raises_clear_error():
+    with pytest.raises(ValueError, match="Unknown active model\\(s\\): knn"):
+        MultiModelTrainer(_config(["svc", "knn"]))
+
+
+def test_empty_active_models_raises_clear_error():
+    with pytest.raises(ValueError, match="ACTIVE_MODELS must contain at least one"):
+        MultiModelTrainer(_config([]))

{melite-0.2.0 → melite-0.2.2}/tests/test_predict.py

@@ -3,7 +3,11 @@
 
 import numpy as np
 import pytest
+import joblib
 from melite.predict import predict
+from sklearn.pipeline import Pipeline as SklearnPipeline
+from sklearn.preprocessing import StandardScaler
+from sklearn.svm import SVC
 
 
 def test_predict_returns_dict(tmp_model):
@@ -73,3 +77,20 @@ def test_3d_input_raises_value_error(tmp_model):
     X_3d = np.random.rand(10, 5, 3).astype(np.float32)
     with pytest.raises(ValueError, match="2-D numpy array"):
         predict(tmp_model, X_3d)
+
+
+def test_predict_loads_exported_svc_pipeline(tmp_path):
+    X_train = np.random.rand(20, 5).astype(np.float32)
+    y_train = np.array([0, 1] * 10, dtype=np.int64)
+    model = SklearnPipeline([
+        ("scaler", StandardScaler()),
+        ("svc", SVC(kernel="linear", C=1, probability=True, random_state=42)),
+    ])
+    model.fit(X_train, y_train)
+    model_path = tmp_path / "Model_SVC_toy.pkl"
+    joblib.dump(model, model_path)
+
+    result = predict(model_path, np.random.rand(4, 5).astype(np.float32))
+
+    assert result["predictions"].shape == (4,)
+    assert result["probabilities"].shape == (4, 2)