mlpipe-cli 0.1.0__py3-none-any.whl

mlpipe/tuning/search.py

@@ -0,0 +1,140 @@
+"""
+Hyperparameter search and model training engine.
+
+Runs cross-validation and hyperparameter optimization strictly on training data,
+ensuring complete data leakage prevention.
+"""
+
+from dataclasses import dataclass, field
+import time
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.model_selection import KFold, RandomizedSearchCV, StratifiedKFold, cross_val_score
+from sklearn.pipeline import Pipeline
+
+from mlpipe.models.registry import ModelCandidate
+from mlpipe.tuning.spaces import get_search_iterations
+from mlpipe.utils.logging import get_logger
+
+logger = get_logger("tuning")
+
+
+@dataclass
+class TuningResult:
+    """Outcome of tuning a single candidate model."""
+
+    candidate_name: str
+    best_pipeline: Optional[Pipeline]
+    best_params: Dict[str, Any]
+    best_cv_score: float
+    training_time_s: float
+    error: Optional[str] = None
+
+
+def tune_candidate(
+    candidate: ModelCandidate,
+    preprocessor: ColumnTransformer,
+    X_train: pd.DataFrame,
+    y_train: pd.Series,
+    primary_metric: str,
+    cv_folds: int = 5,
+    mode: str = "balanced",
+    random_seed: int = 42,
+) -> TuningResult:
+    """
+    Train and tune a candidate model using RandomizedSearchCV on X_train.
+
+    Never touches test data. Preprocessing is encapsulated inside the Pipeline
+    so each CV fold fits preprocessing strictly on that fold's training portion.
+    """
+    t_start = time.perf_counter()
+
+    try:
+        # 1. Instantiate base estimator
+        base_estimator = candidate.create_estimator(random_seed=random_seed)
+
+        # 2. Construct complete pipeline
+        pipeline = Pipeline([
+            ("preprocessor", preprocessor),
+            ("estimator", base_estimator),
+        ])
+
+        # 3. Determine CV splitter
+        n_samples = len(X_train)
+        effective_folds = min(cv_folds, n_samples)
+
+        if candidate.task == "classification":
+            val_counts = y_train.value_counts()
+            min_class = int(val_counts.min()) if len(val_counts) > 0 else 2
+            effective_folds = max(2, min(effective_folds, min_class))
+            cv = StratifiedKFold(n_splits=effective_folds, shuffle=True, random_state=random_seed)
+        else:
+            effective_folds = max(2, effective_folds)
+            cv = KFold(n_splits=effective_folds, shuffle=True, random_state=random_seed)
+
+        # 4. Get search space and format for Pipeline
+        raw_space = candidate.get_search_space(mode)
+        param_distributions = {
+            f"estimator__{k}": v for k, v in raw_space.items()
+        }
+
+        n_iter = get_search_iterations(mode)
+
+        if param_distributions:
+            search = RandomizedSearchCV(
+                estimator=pipeline,
+                param_distributions=param_distributions,
+                n_iter=n_iter,
+                cv=cv,
+                scoring=primary_metric,
+                random_state=random_seed,
+                n_jobs=None,
+                refit=True,
+                error_score=np.nan,
+            )
+
+            search.fit(X_train, y_train)
+
+            best_pipe = search.best_estimator_
+            best_cv = float(search.best_score_)
+            best_params = {
+                k.replace("estimator__", ""): (
+                    float(round(v, 4)) if isinstance(v, (float, np.floating)) else v
+                )
+                for k, v in search.best_params_.items()
+            }
+        else:
+            # If no params to tune, fit and cross-validate directly
+            cv_scores = cross_val_score(
+                pipeline, X_train, y_train, cv=cv, scoring=primary_metric, n_jobs=-1
+            )
+            pipeline.fit(X_train, y_train)
+            best_pipe = pipeline
+            best_cv = float(cv_scores.mean())
+            best_params = {}
+
+        elapsed = round(time.perf_counter() - t_start, 2)
+
+        return TuningResult(
+            candidate_name=candidate.name,
+            best_pipeline=best_pipe,
+            best_params=best_params,
+            best_cv_score=round(best_cv, 4),
+            training_time_s=elapsed,
+            error=None,
+        )
+
+    except Exception as e:
+        elapsed = round(time.perf_counter() - t_start, 2)
+        logger.warning("Training failed for %s: %s", candidate.name, e)
+        return TuningResult(
+            candidate_name=candidate.name,
+            best_pipeline=None,
+            best_params={},
+            best_cv_score=-9999.0,
+            training_time_s=elapsed,
+            error=str(e),
+        )

mlpipe/tuning/spaces.py

@@ -0,0 +1,11 @@
+"""Tuning budgets and search configuration."""
+
+
+def get_search_iterations(mode: str) -> int:
+    """Return number of RandomizedSearchCV iterations for the training mode."""
+    mode = str(mode).lower()
+    if mode == "fast":
+        return 3
+    elif mode == "thorough":
+        return 20
+    return 8  # balanced

mlpipe/utils/__init__.py

@@ -0,0 +1,13 @@
+"""Utility modules for MLPipe."""
+
+from mlpipe.utils.hashing import compute_file_hash
+from mlpipe.utils.logging import configure_logging, get_logger
+from mlpipe.utils.timing import Timer, time_block
+
+__all__ = [
+    "compute_file_hash",
+    "configure_logging",
+    "get_logger",
+    "Timer",
+    "time_block",
+]

mlpipe/utils/hashing.py

@@ -0,0 +1,15 @@
+"""Hashing utilities for data integrity and artifact verification."""
+
+import hashlib
+from pathlib import Path
+from typing import Union
+
+
+def compute_file_hash(path: Union[str, Path]) -> str:
+    """Compute SHA-256 hash of a file."""
+    path = Path(path)
+    hasher = hashlib.sha256()
+    with open(path, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            hasher.update(chunk)
+    return hasher.hexdigest()

mlpipe/utils/logging.py

@@ -0,0 +1,37 @@
+"""Logging utilities for MLPipe."""
+
+import logging
+import sys
+from typing import Optional
+
+_LOGGER_NAME = "mlpipe"
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """Get the MLPipe logger."""
+    logger_name = _LOGGER_NAME if not name else f"{_LOGGER_NAME}.{name}"
+    return logging.getLogger(logger_name)
+
+
+def configure_logging(verbose: bool = False) -> None:
+    """Configure MLPipe logging format and verbosity."""
+    logger = logging.getLogger(_LOGGER_NAME)
+    logger.handlers.clear()
+
+    level = logging.DEBUG if verbose else logging.INFO
+    logger.setLevel(level)
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setLevel(level)
+
+    if verbose:
+        formatter = logging.Formatter(
+            fmt="[%(asctime)s] [%(levelname)s] [%(name)s] %(message)s",
+            datefmt="%H:%M:%S",
+        )
+    else:
+        formatter = logging.Formatter(fmt="%(message)s")
+
+    handler.setFormatter(formatter)
+    logger.addHandler(handler)
+    logger.propagate = False

mlpipe/utils/timing.py

@@ -0,0 +1,33 @@
+"""Timing utilities for ML execution benchmarking."""
+
+import time
+from contextlib import contextmanager
+from typing import Generator
+
+
+class Timer:
+    """Timer utility to record elapsed execution time."""
+
+    def __init__(self):
+        self.start_time: float = 0.0
+        self.end_time: float = 0.0
+        self.elapsed: float = 0.0
+
+    def start(self) -> "Timer":
+        self.start_time = time.perf_counter()
+        return self
+
+    def stop(self) -> float:
+        self.end_time = time.perf_counter()
+        self.elapsed = self.end_time - self.start_time
+        return self.elapsed
+
+
+@contextmanager
+def time_block() -> Generator[Timer, None, None]:
+    """Context manager to measure block execution time."""
+    timer = Timer().start()
+    try:
+        yield timer
+    finally:
+        timer.stop()

mlpipe/version.py

@@ -0,0 +1,3 @@
+"""MLPipe version."""
+
+__version__ = "0.1.0"

mlpipe_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,264 @@
+Metadata-Version: 2.4
+Name: mlpipe-cli
+Version: 0.1.0
+Summary: Production-ready tabular ML automation library and terminal CLI
+Author: MLPipe Contributors
+License: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: scikit-learn>=1.3.0
+Requires-Dist: joblib>=1.3.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: typer[all]>=0.9.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# MLPipe
+
+> **Production-ready tabular ML automation library and terminal CLI.**  
+> From raw CSV to evaluated, reproducible, deployable model pipelines in one command.
+
+---
+
+## 🚀 Overview
+
+**MLPipe** automates the repetitive engineering lifecycle for tabular machine learning models. Simply point MLPipe at your CSV dataset and designate a target column:
+
+```
+Raw CSV Dataset
+      ↓
+Data Ingestion (Format validation & SHA-256 integrity hash)
+      ↓
+Data Profiling (Column types, distributions, missingness & flags)
+      ↓
+Pre-training Validation (Fatal structural errors & non-blocking warnings)
+      ↓
+Task Detection (Automatic classification vs. regression inference)
+      ↓
+Leakage-Free Splitting (Stratified or random train/test split)
+      ↓
+Automated Preprocessing (ColumnTransformer: imputation, scaling & encoding)
+      ↓
+Multi-Model Training & Tuning (RandomizedSearchCV strictly on training folds)
+      ↓
+CV-Based Leaderboard Ranking (Winning model selected by CV, not test set)
+      ↓
+Held-Out Test Evaluation (Unbiased final metrics & confusion matrix)
+      ↓
+Model Explainability (Recovered transformed feature importances & coefficients)
+      ↓
+Artifact Generation (Reusable pipeline, model, metadata & reports)
+      ↓
+Instant Predictions (CLI & Python inference)
+```
+
+No hardcoded results. No fake training. Real scikit-learn models and metrics computed on your CPU machine.
+
+---
+
+## 📦 Installation
+
+Install locally in editable mode:
+
+```bash
+git clone https://github.com/your-org/mlpipe.git
+cd mlpipe
+pip install -e .
+```
+
+Verify the installation:
+
+```bash
+mlpipe --version
+```
+
+---
+
+## ⚡ Quick Start
+
+### 1. Terminal CLI
+
+Train an end-to-end classification pipeline:
+
+```bash
+mlpipe train demo_data/customer_churn.csv --target churn
+```
+
+Train a regression pipeline:
+
+```bash
+mlpipe train demo_data/house_prices.csv --target price
+```
+
+Generate predictions on new data:
+
+```bash
+mlpipe predict ./mlpipe_runs/<run_id>/pipeline.joblib demo_data/customer_churn.csv --output predictions.csv
+```
+
+### 2. Python API
+
+```python
+from mlpipe import Pipeline
+
+# 1. Initialize pipeline
+pipeline = Pipeline(
+    target="churn",
+    task="auto",       # auto-detects classification vs regression
+    mode="balanced",   # "fast", "balanced", or "thorough"
+)
+
+# 2. Fit pipeline on CSV or DataFrame
+result = pipeline.fit("demo_data/customer_churn.csv")
+
+# 3. Inspect results
+print("Best Model:", result.best_model)
+print("Primary Metric:", result.primary_metric)
+print("CV Score:", result.best_cv_score)
+print("Test Score:", result.test_score)
+print("Test Metrics:", result.metrics)
+
+# 4. Save and reload pipeline
+pipeline.save("./trained_models/churn_model")
+
+loaded_pipeline = Pipeline.load("./trained_models/churn_model")
+predictions = loaded_pipeline.predict("demo_data/customer_churn.csv")
+print("Predictions:", predictions[:5])
+```
+
+---
+
+## 🛠️ CLI Command Reference
+
+### `mlpipe train`
+Train multiple candidate models, tune hyperparameters, rank on leaderboard, and save artifacts.
+
+```bash
+mlpipe train <data.csv> --target <target_col> [OPTIONS]
+```
+
+**Options:**
+- `--target, -t`: Target column name to predict (required).
+- `--task`: Task type override: `auto` (default), `classification`, or `regression`.
+- `--mode, -m`: Training mode budget: `fast`, `balanced` (default), or `thorough`.
+- `--output, -o`: Base directory to store run artifacts (default: `./mlpipe_runs`).
+- `--format, -f`: Output format: `human` (default) or `json`.
+- `--verbose`: Enable detailed debug logging.
+
+### `mlpipe profile`
+Inspect dataset summary, column types, statistics, missingness, and structural issues.
+
+```bash
+mlpipe profile demo_data/customer_churn.csv
+mlpipe profile demo_data/customer_churn.csv --format json
+```
+
+### `mlpipe validate`
+Run pre-training validation checks on dataset and target.
+
+```bash
+mlpipe validate demo_data/customer_churn.csv --target churn
+```
+
+### `mlpipe predict`
+Generate predictions on a new CSV dataset using a saved pipeline.
+
+```bash
+mlpipe predict ./mlpipe_runs/<run_id>/pipeline.joblib new_data.csv --output preds.csv
+```
+
+### `mlpipe inspect`
+Inspect metadata, configuration, metrics, and generated artifacts from a previous run directory.
+
+```bash
+mlpipe inspect ./mlpipe_runs/<run_id>
+mlpipe inspect ./mlpipe_runs/<run_id> --format json
+```
+
+### `mlpipe version`
+Display the current version of MLPipe.
+
+```bash
+mlpipe version
+```
+
+---
+
+## 🧠 Supported Models
+
+### Classification
+- **Logistic Regression** (L2 penalty, liblinear/lbfgs/saga solvers)
+- **Random Forest Classifier** (trees, depth, sample split/leaf tuning)
+- **HistGradientBoosting Classifier** (iterations, learning rate, leaf bounds)
+- **Decision Tree Classifier** (depth, split thresholds, criteria)
+- **K-Nearest Neighbors** (neighbors, weights, distance metrics)
+
+### Regression
+- **Ridge Regression** (regularization alpha, solver selection)
+- **Random Forest Regressor** (trees, depth, sample bounds, features)
+- **HistGradientBoosting Regressor** (iterations, rate, regularization)
+- **Decision Tree Regressor** (depth, split criteria, sample leaves)
+
+---
+
+## 🔒 Data Leakage Prevention Guarantee
+
+MLPipe adheres to strict data integrity standards:
+1. **No Full-Data Transformations:** Preprocessing pipelines are never fitted on the entire dataset.
+2. **Train/Test Split First:** The raw dataset is partitioned (default 80% train, 20% test) before column classification and transformer fitting.
+3. **Cross-Validation Inside Pipelines:** During hyperparameter search, sklearn `Pipeline` objects fit transformers solely on the internal training fold of each split.
+4. **CV-Based Model Selection:** The winning model is selected strictly based on CV score on the training set. The held-out test set is evaluated exactly once for unbiased reporting.
+
+---
+
+## 📁 Artifact Structure
+
+Each completed training run generates a self-contained bundle under `./mlpipe_runs/<run_id>/`:
+
+```text
+mlpipe_runs/<run_id>/
+├── pipeline.joblib          # Complete fitted pipeline (preprocessor + estimator)
+├── model.joblib             # Fitted estimator alone
+├── metrics.json             # CV and test evaluation metrics
+├── leaderboard.json         # Complete ranked candidate comparison table
+├── metadata.json            # Dataset hash, seed, mode, environment & parameters
+├── feature_importance.json  # Top features with recovered transformed names
+└── report.txt               # Plain text human-readable run summary
+```
+
+---
+
+## 🧪 Running Tests
+
+Run the complete test suite using `pytest`:
+
+```bash
+pytest
+```
+
+Run with verbose test output:
+
+```bash
+pytest -v
+```
+
+---
+
+## 📄 License
+
+MIT License. See [LICENSE](LICENSE) for details.

mlpipe_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,46 @@
+mlpipe/__init__.py,sha256=9SL7L_xZkvqg-X_i94AzlvOy-N0X_agPY2tYxtPKvsM,1009
+mlpipe/__main__.py,sha256=N655XDgrdsIN-pSBZ3niJVt4SMx-rA89GswQ1wtL02o,123
+mlpipe/version.py,sha256=sEWauLYY0-L5PvpCgQKUvLpmAcG9sLEzOrLCQ3few-0,45
+mlpipe/artifacts/__init__.py,sha256=FzoR6sWUHVBnxzLDaNHVIeVG8tMEKyNl1x1pdePaOe0,454
+mlpipe/artifacts/manager.py,sha256=OH1rKzGzhqK72XFWzGL7nX85YsxeE7wJZRlNklfHGuY,9497
+mlpipe/artifacts/serialization.py,sha256=7H05Ksipf7mMkEhRwuqxbMHjTrbrWU8ZqD5tdHSVvJk,2075
+mlpipe/cli/__init__.py,sha256=EqXs6vMQyYCqwFubH-gx1PVjbLag8wEZeimgzyG5l1k,81
+mlpipe/cli/main.py,sha256=mh4cX-gcuazLIB9JGA8MlAdKBMYnzxn80WW8u8trl50,26628
+mlpipe/core/__init__.py,sha256=2qdbY5J_YzunTrhaRVPNRxUrnF4jG1ku_CS5dH_XWlE,766
+mlpipe/core/config.py,sha256=eoHFi2TZJhz2RhBZVRvwN4EXZ-sEsIFhSmNSrmDmKdU,2398
+mlpipe/core/exceptions.py,sha256=8Qq6xoFWp1ine9K2-vZDRKaJDWRqj_j1czQpe2_wk70,1559
+mlpipe/core/pipeline.py,sha256=UbCVdn-QwPyHEBue7XGdDGL3xzpQIfF_xGi17rIMpjU,18342
+mlpipe/core/result.py,sha256=yzZ5huwzz3tHWbzbeLGayPZfk0MMbdOg801aiKPBS9k,1633
+mlpipe/data/__init__.py,sha256=sZxmu8PewKdOGMFX1HhTTiu7KBG3wYTc8uDY7WrD2cY,612
+mlpipe/data/ingestion.py,sha256=ngGRvYJbH2qa_LArtw3iRx7OUDAWMVEM5YkUvy2BsQw,4156
+mlpipe/data/profiling.py,sha256=cWTUXgiuFLv_mTOMjbKfCbJ9cSxTaCDWLnmI3CTX-xc,7772
+mlpipe/data/splitting.py,sha256=8uUmRvkwqXr0uw03yGXb6mMn2MksVKmpNyguaueJAGU,4079
+mlpipe/data/validation.py,sha256=VNCvW9N2PRk094Ms4Q45LftX2zSfjAV2NPbsOSuqTLI,9113
+mlpipe/evaluation/__init__.py,sha256=uFunO9rZEQ3s_JvUtxfpdT4IhtYnRh9Azr-wFmPFRSA,369
+mlpipe/evaluation/evaluator.py,sha256=1u0Iu8XVl8qGvtrZn6vPzpQrwcGo9KmxfqCJ_kYbF10,4740
+mlpipe/evaluation/metrics.py,sha256=Tlb_qjQtEJXHeZnTrB4L94ZxzkeTVLkg0RxEEmorXsQ,1676
+mlpipe/explainability/__init__.py,sha256=chP_Wj0BJu8sfyfKUkddVMj99rlnCEBjYPq8_VgmrWs,155
+mlpipe/explainability/importance.py,sha256=Rm5gv5BkXwXbVmz18MCwXyA1wq5uU788pvfg5cMRAl0,2066
+mlpipe/models/__init__.py,sha256=T8pwlu84QvslpEhKKDh9aluycpLLZ5vMdGQuJMigq6E,433
+mlpipe/models/classification.py,sha256=Tov2ke_aU-p4itJBgsbSrGR3caeVVBMl3hJJtpcfMG0,5581
+mlpipe/models/registry.py,sha256=iPzVd9JX56JOth0G9xdYDohxfDQex5wjkwXhvSpiTtc,1264
+mlpipe/models/regression.py,sha256=EnvAjnTP4AxDOXry_nTf02KM-aGa_5QRVMqNJwCCAE4,4535
+mlpipe/models/selection.py,sha256=BVmH306h-yRRvT4UMQrXxxpB6HX0g_CNXb44_uQgTHY,839
+mlpipe/preprocessing/__init__.py,sha256=2j8rtLAiwhZXhZmCCmx9yieqDrA7X3hh7wZmZFwS5aw,651
+mlpipe/preprocessing/builder.py,sha256=B1BYsf1aRaZTM7dvHBmsPZuGv0XVCLuQyCk-uwcZN9E,5407
+mlpipe/preprocessing/categorical.py,sha256=xr3fyu7YURwo5tlSHB8VUTvenheh-61jJeKpSSPffzY,578
+mlpipe/preprocessing/datetime.py,sha256=6rL4PNwrmPBJSNu8fjRkZXG8FtMjXdo4SxnJPSDDpI4,1838
+mlpipe/preprocessing/numeric.py,sha256=dV593TybFvKA181J1wcWB-sq2eACy3YmE6OE3FkjT0g,552
+mlpipe/tuning/__init__.py,sha256=9L73xQFbNMQaFv5Jb_jemFnfKlTBmM82P-kRjZcQaoo,262
+mlpipe/tuning/search.py,sha256=w5CIgR3kCQqBoj7S2Wp0qzAbc9f5SYECLEEYxl0aMaU,4560
+mlpipe/tuning/spaces.py,sha256=Q24XMqNwMy3ds0vh8WbDFCzCqiueJC3aS3baYLCGlsc,315
+mlpipe/utils/__init__.py,sha256=f1L5EmOgp0d5jNJAm3gM-3qPbpQLOewAOxekPOYqptk,313
+mlpipe/utils/hashing.py,sha256=tQKCHjByFO_hyU4PQwZOZZi1ozvpzW9X-eYnJlZc_2c,436
+mlpipe/utils/logging.py,sha256=8P2a3uXH7gzAo3lOinFmCN1h8WHRIInEhqs0-AD7e24,1008
+mlpipe/utils/timing.py,sha256=GIa1wi4N_O-lFz0eSsdJPDZty76HjNaxFL3Um7wwLCc,812
+mlpipe_cli-0.1.0.dist-info/licenses/LICENSE,sha256=JTJyA0ZggMhgGY0nFJtstNzYedEE-sBRJFDvrB1eV-4,1076
+mlpipe_cli-0.1.0.dist-info/METADATA,sha256=dKcmOICyKHx9gBIfMwoyT976fhyfDE68D_q888uO7Xo,8064
+mlpipe_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+mlpipe_cli-0.1.0.dist-info/entry_points.txt,sha256=xRznh8TJmM2kkk63dZ6q-xxnwS6osZNHrJ18hi_4QAQ,47
+mlpipe_cli-0.1.0.dist-info/top_level.txt,sha256=yD70na0QWAVtUCmM4oDydp2ppLncPl5RZkL2evcNQGI,7
+mlpipe_cli-0.1.0.dist-info/RECORD,,

mlpipe_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mlpipe_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mlpipe = mlpipe.cli.main:app

mlpipe_cli-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 MLPipe Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mlpipe_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+mlpipe