mlcompare-dev 0.1.1__tar.gz

mlcompare_dev-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Manish Kumar
+
+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.

mlcompare_dev-0.1.1/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: mlcompare-dev
+Version: 0.1.1
+Summary: Compare classification and regression ML models
+Author: Manish Kumar
+License: MIT
+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.4.0
+Requires-Dist: joblib>=1.3.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🚀 MLCompare
+
+**MLCompare** is a beginner-friendly Python library to compare multiple Machine Learning models with just a few lines of code.
+
+Instead of writing repetitive code for training and evaluating models, MLCompare automatically trains multiple algorithms, compares their performance, selects the best model, and allows prediction and model saving.
+
+---
+
+# ✨ Features
+
+- ✅ Automatic Classification & Regression Detection
+- ✅ Train Multiple ML Models
+- ✅ Compare Model Performance
+- ✅ Automatically Select Best Model
+- ✅ Predict Using Best Model
+- ✅ Save & Load Trained Model
+- ✅ Simple Beginner-Friendly API
+
+---
+
+# 📦 Installation
+
+```bash
+pip install mlcompare
+```
+
+Or install locally
+
+```bash
+pip install -e .
+```
+
+---
+
+# 📚 Supported Models
+
+## Classification
+
+- Logistic Regression
+- K-Nearest Neighbors (KNN)
+- Support Vector Machine (SVM)
+- Decision Tree
+- Random Forest
+- AdaBoost
+- Gradient Boosting
+- Extra Trees
+
+## Regression
+
+- Linear Regression
+- Ridge Regression
+- Lasso Regression
+- ElasticNet
+- Decision Tree Regressor
+- Random Forest Regressor
+- Gradient Boosting Regressor
+- Extra Trees Regressor
+
+---
+
+# 🚀 Quick Start
+
+```python
+from mlcompare import MLCompare
+import pandas as pd
+
+df = pd.read_csv("data.csv")
+
+ml = MLCompare(
+    data=df,
+    target="target"
+)
+
+results = ml.compare()
+
+print(results)
+```
+
+---
+
+# 🏆 Best Model
+
+```python
+print(ml.best_model_name)
+```
+
+---
+
+# 🔮 Prediction
+
+```python
+new_data = df.drop(columns=["target"]).head()
+
+predictions = ml.predict(new_data)
+
+print(predictions)
+```
+
+---
+
+# 💾 Save Model
+
+```python
+ml.save("best_model.pkl")
+```
+
+---
+
+# 📂 Load Model
+
+```python
+ml.load("best_model.pkl")
+```
+
+---
+
+# 📊 Example Output
+
+| Model | Accuracy |
+|--------|----------|
+| SVM | 0.95 |
+| Random Forest | 0.94 |
+| Extra Trees | 0.93 |
+| Logistic Regression | 0.91 |
+
+---
+
+# 📁 Project Structure
+
+```
+mlcompare/
+│
+├── core.py
+├── models.py
+├── metrics.py
+├── utils.py
+├── save.py
+├── version.py
+└── __init__.py
+```
+
+---
+
+# 🛠 Requirements
+
+- Python 3.10+
+- pandas
+- numpy
+- scikit-learn
+- joblib
+
+---
+
+# 📌 Roadmap
+
+Upcoming Features
+
+- Hyperparameter Tuning
+- Cross Validation
+- Feature Importance
+- Confusion Matrix
+- ROC-AUC Score
+- StandardScaler Support
+- Missing Value Handling
+- Categorical Encoding
+- XGBoost
+- LightGBM
+- CatBoost
+
+---
+
+# 🤝 Contributing
+
+Contributions are welcome!
+
+Feel free to open an Issue or submit a Pull Request.
+
+---
+
+# 📄 License
+
+MIT License
+
+---
+
+# 👨‍💻 Author
+
+**Manish Kumar**
+
+GitHub:
+https://github.com/Developer-Manish007

mlcompare_dev-0.1.1/README.md

@@ -0,0 +1,191 @@
+# 🚀 MLCompare
+
+**MLCompare** is a beginner-friendly Python library to compare multiple Machine Learning models with just a few lines of code.
+
+Instead of writing repetitive code for training and evaluating models, MLCompare automatically trains multiple algorithms, compares their performance, selects the best model, and allows prediction and model saving.
+
+---
+
+# ✨ Features
+
+- ✅ Automatic Classification & Regression Detection
+- ✅ Train Multiple ML Models
+- ✅ Compare Model Performance
+- ✅ Automatically Select Best Model
+- ✅ Predict Using Best Model
+- ✅ Save & Load Trained Model
+- ✅ Simple Beginner-Friendly API
+
+---
+
+# 📦 Installation
+
+```bash
+pip install mlcompare
+```
+
+Or install locally
+
+```bash
+pip install -e .
+```
+
+---
+
+# 📚 Supported Models
+
+## Classification
+
+- Logistic Regression
+- K-Nearest Neighbors (KNN)
+- Support Vector Machine (SVM)
+- Decision Tree
+- Random Forest
+- AdaBoost
+- Gradient Boosting
+- Extra Trees
+
+## Regression
+
+- Linear Regression
+- Ridge Regression
+- Lasso Regression
+- ElasticNet
+- Decision Tree Regressor
+- Random Forest Regressor
+- Gradient Boosting Regressor
+- Extra Trees Regressor
+
+---
+
+# 🚀 Quick Start
+
+```python
+from mlcompare import MLCompare
+import pandas as pd
+
+df = pd.read_csv("data.csv")
+
+ml = MLCompare(
+    data=df,
+    target="target"
+)
+
+results = ml.compare()
+
+print(results)
+```
+
+---
+
+# 🏆 Best Model
+
+```python
+print(ml.best_model_name)
+```
+
+---
+
+# 🔮 Prediction
+
+```python
+new_data = df.drop(columns=["target"]).head()
+
+predictions = ml.predict(new_data)
+
+print(predictions)
+```
+
+---
+
+# 💾 Save Model
+
+```python
+ml.save("best_model.pkl")
+```
+
+---
+
+# 📂 Load Model
+
+```python
+ml.load("best_model.pkl")
+```
+
+---
+
+# 📊 Example Output
+
+| Model | Accuracy |
+|--------|----------|
+| SVM | 0.95 |
+| Random Forest | 0.94 |
+| Extra Trees | 0.93 |
+| Logistic Regression | 0.91 |
+
+---
+
+# 📁 Project Structure
+
+```
+mlcompare/
+│
+├── core.py
+├── models.py
+├── metrics.py
+├── utils.py
+├── save.py
+├── version.py
+└── __init__.py
+```
+
+---
+
+# 🛠 Requirements
+
+- Python 3.10+
+- pandas
+- numpy
+- scikit-learn
+- joblib
+
+---
+
+# 📌 Roadmap
+
+Upcoming Features
+
+- Hyperparameter Tuning
+- Cross Validation
+- Feature Importance
+- Confusion Matrix
+- ROC-AUC Score
+- StandardScaler Support
+- Missing Value Handling
+- Categorical Encoding
+- XGBoost
+- LightGBM
+- CatBoost
+
+---
+
+# 🤝 Contributing
+
+Contributions are welcome!
+
+Feel free to open an Issue or submit a Pull Request.
+
+---
+
+# 📄 License
+
+MIT License
+
+---
+
+# 👨‍💻 Author
+
+**Manish Kumar**
+
+GitHub:
+https://github.com/Developer-Manish007

mlcompare_dev-0.1.1/mlcompare/__init__.py

@@ -0,0 +1,6 @@
+"""MLCompare - Compare classification and regression models with common metrics."""
+
+from mlcompare.core import MLCompare
+from mlcompare.version import __version__
+
+__all__ = ["MLCompare", "__version__"]

mlcompare_dev-0.1.1/mlcompare/core.py

@@ -0,0 +1,103 @@
+"""
+Main MLCompare class.
+"""
+
+import pandas as pd
+
+from mlcompare.metrics import compute_metrics
+from mlcompare.models import get_models
+from mlcompare.save import save_model
+from mlcompare.utils import detect_problem, split_data, validate_inputs
+
+
+class MLCompare:
+    """
+    Compare multiple machine learning models.
+    """
+
+    def __init__(
+        self,
+        data: pd.DataFrame,
+        target: str,
+        test_size: float = 0.2,
+        random_state: int = 42,
+    ):
+        self.data = data
+        self.target = target
+        self.test_size = test_size
+        self.random_state = random_state
+
+        self.problem_type = None
+        self.models = None
+        self.results = None
+        self.best_model = None
+        self.best_model_name = None
+        self.trained_models = {}
+
+    def compare(self):
+        """
+        Train and compare all machine learning models.
+        """
+
+        validate_inputs(self.data, self.target)
+
+        y = self.data[self.target]
+        self.problem_type = detect_problem(y)
+
+        X_train, X_test, y_train, y_test = split_data(
+            self.data,
+            self.target,
+            self.problem_type,
+            self.test_size,
+            self.random_state,
+        )
+
+        self.models = get_models(self.problem_type)
+
+        results = []
+        trained_models = {}
+
+        for name, model in self.models.items():
+            model.fit(X_train, y_train)
+            y_pred = model.predict(X_test)
+            metrics = compute_metrics(self.problem_type, y_test, y_pred)
+
+            trained_models[name] = model
+            results.append({"Model": name, **metrics})
+
+        self.results = pd.DataFrame(results)
+
+        if self.problem_type == "classification":
+            self.results = self.results.sort_values(
+                by="Accuracy",
+                ascending=False,
+            ).reset_index(drop=True)
+        else:
+            self.results = self.results.sort_values(
+                by="R2 Score",
+                ascending=False,
+            ).reset_index(drop=True)
+
+        if not self.results.empty:
+            best_name = self.results.iloc[0]["Model"]
+            self.best_model_name = best_name
+            self.best_model = trained_models[best_name]
+
+        self.trained_models = trained_models
+
+        return self.results
+
+    def predict(self, data):
+        """
+        Predict using the best trained model.
+        """
+        if self.best_model is None:
+            raise ValueError("No trained model found. Run compare() first.")
+
+        return self.best_model.predict(data)
+
+    def save(self, path: str):
+        """
+        Save the best trained model.
+        """
+        save_model(self.best_model, path)

mlcompare_dev-0.1.1/mlcompare/metrics.py

@@ -0,0 +1,83 @@
+"""
+Evaluation metrics for MLCompare.
+"""
+
+import numpy as np
+
+from sklearn.metrics import (
+    accuracy_score,
+    precision_score,
+    recall_score,
+    f1_score,
+    mean_absolute_error,
+    mean_squared_error,
+    r2_score,
+)
+
+def compute_metrics(problem_type, y_true, y_pred):
+    """
+    Compute evaluation metrics.
+
+    Parameters
+    ----------
+    problem_type : str
+        Either 'classification' or 'regression'.
+
+    y_true : array-like
+        Actual target values.
+
+    y_pred : array-like
+        Predicted target values.
+
+    Returns
+    -------
+    dict
+        Dictionary containing evaluation metrics.
+    """
+
+    if problem_type == "classification":
+
+        return {
+
+            "Accuracy": accuracy_score(y_true, y_pred),
+
+            "Precision": precision_score(
+                y_true,
+                y_pred,
+                average="weighted",
+                zero_division=0,
+            ),
+
+            "Recall": recall_score(
+                y_true,
+                y_pred,
+                average="weighted",
+                zero_division=0,
+            ),
+
+            "F1 Score": f1_score(
+                y_true,
+                y_pred,
+                average="weighted",
+                zero_division=0,
+            ),
+        }
+    elif problem_type == "regression":
+
+        mse = mean_squared_error(y_true, y_pred)
+
+        return {
+
+            "MAE": mean_absolute_error(y_true, y_pred),
+
+            "MSE": mse,
+
+            "RMSE": np.sqrt(mse),
+
+            "R2 Score": r2_score(y_true, y_pred),
+        }
+    else:
+
+        raise ValueError(
+            "Problem type must be 'classification' or 'regression'."
+        )

mlcompare_dev-0.1.1/mlcompare/models.py

@@ -0,0 +1,111 @@
+"""
+All machine learning models used in MLCompare.
+"""
+
+from sklearn.linear_model import (
+    LogisticRegression,
+    LinearRegression,
+    Ridge,
+    Lasso,
+    ElasticNet,
+)
+
+from sklearn.neighbors import KNeighborsClassifier
+
+from sklearn.svm import SVC
+
+from sklearn.tree import (
+    DecisionTreeClassifier,
+    DecisionTreeRegressor,
+)
+
+from sklearn.ensemble import (
+    RandomForestClassifier,
+    RandomForestRegressor,
+    AdaBoostClassifier,
+    GradientBoostingClassifier,
+    GradientBoostingRegressor,
+    ExtraTreesClassifier,
+    ExtraTreesRegressor,
+)
+
+RANDOM_STATE = 42
+
+
+# ----------------------------------------------------------------------------  
+
+# Classification models
+
+classification_models = {
+
+    "Logistic Regression": LogisticRegression(random_state=RANDOM_STATE),
+
+    "KNN": KNeighborsClassifier(),
+
+    "SVM": SVC(random_state=RANDOM_STATE),
+
+    "Decision Tree": DecisionTreeClassifier(random_state=RANDOM_STATE),
+
+    "Random Forest": RandomForestClassifier(random_state=RANDOM_STATE),
+
+    "AdaBoost": AdaBoostClassifier(random_state=RANDOM_STATE),
+
+    "Gradient Boosting": GradientBoostingClassifier(random_state=RANDOM_STATE),
+
+    "Extra Trees": ExtraTreesClassifier(random_state=RANDOM_STATE),
+
+}
+
+# ----------------------------------------------------------------------------  
+
+# Regression models
+
+regression_models = {
+
+    "Linear Regression": LinearRegression(),
+
+    "Ridge": Ridge(),
+
+    "Lasso": Lasso(),
+
+    "ElasticNet": ElasticNet(),
+
+    "Decision Tree": DecisionTreeRegressor(random_state=RANDOM_STATE),
+
+    "Random Forest": RandomForestRegressor(random_state=RANDOM_STATE),
+
+    "Gradient Boosting": GradientBoostingRegressor(random_state=RANDOM_STATE),
+
+    "Extra Trees": ExtraTreesRegressor(random_state=RANDOM_STATE),
+
+}
+
+
+# ----------------------------------------------------------------------------  
+# Get models
+def get_models(problem_type: str):
+    """
+    Return machine learning models based on problem type.
+
+    Parameters
+    ----------
+    problem_type : str
+        Either 'classification' or 'regression'.
+
+    Returns
+    -------
+    dict
+        Dictionary containing model names and model objects.
+    """
+
+    if problem_type == "classification":
+        return classification_models
+
+    elif problem_type == "regression":
+        return regression_models
+
+    else:
+        raise ValueError(
+            "Problem type must be 'classification' or 'regression'."
+        )
+

mlcompare_dev-0.1.1/mlcompare/save.py

@@ -0,0 +1,49 @@
+"""
+Save and load MLCompare models.
+"""
+
+import joblib
+
+
+def save_model(model: object, path: str) -> None:
+    """
+    Save a trained machine learning model to disk.
+
+    Parameters
+    ----------
+    model : object
+        Trained machine learning model.
+
+    path : str
+        File path where the model will be saved.
+
+    Raises
+    ------
+    ValueError
+        If the model is None.
+    """
+
+    if model is None:
+        raise ValueError(
+            "No trained model found. Run compare() before saving."
+        )
+
+    joblib.dump(model, path)
+
+
+def load_model(path: str) -> object:
+    """
+    Load a trained machine learning model from disk.
+
+    Parameters
+    ----------
+    path : str
+        Path to the saved model.
+
+    Returns
+    -------
+    object
+        Loaded machine learning model.
+    """
+
+    return joblib.load(path)

mlcompare_dev-0.1.1/mlcompare/utils.py

@@ -0,0 +1,123 @@
+"""
+Utility functions for MLCompare.
+"""
+
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+
+
+# Validate Inputs()
+## ----------------------------------------------------------------------------
+def validate_inputs(data, target=None):
+    """
+    Validate input dataset and target values.
+
+    This function supports two calling patterns:
+    - validate_inputs(data_frame, target_column_name)
+    - validate_inputs(features, target_series)
+    """
+
+    if isinstance(data, pd.DataFrame) and isinstance(target, str):
+        if data.empty:
+            raise ValueError("Input DataFrame is empty.")
+
+        if target not in data.columns:
+            raise ValueError(f"Target column '{target}' not found.")
+
+        if data[target].isnull().all():
+            raise ValueError("Target column contains only missing values.")
+
+        return data.drop(columns=[target]), data[target]
+
+    if target is None:
+        raise TypeError("target must be provided.")
+
+    X = data
+    y = pd.Series(target)
+
+    if isinstance(X, pd.DataFrame) and X.empty:
+        raise ValueError("Input DataFrame is empty.")
+
+    if y.empty:
+        raise ValueError("Target values are empty.")
+
+    if y.isnull().all():
+        raise ValueError("Target column contains only missing values.")
+
+    return X, y
+
+
+# 2️⃣ detect_problem()
+def detect_problem(y):
+    """
+    Automatically detect classification or regression.
+    """
+
+    if (
+        y.dtype == "object"
+        or str(y.dtype) == "category"
+        or y.dtype == "bool"
+    ):
+        return "classification"
+
+    elif pd.api.types.is_integer_dtype(y):
+        if y.nunique() <= 20:
+            return "classification"
+        return "regression"
+
+    elif pd.api.types.is_float_dtype(y):
+        return "regression"
+
+    else:
+        raise ValueError("Unable to detect problem type.")
+
+
+# 3️⃣ split_data()
+def split_data(
+    data,
+    target=None,
+    problem_type=None,
+    test_size=0.2,
+    random_state=42,
+):
+    """
+    Split dataset into train and test sets.
+
+    Supports both the convenience form with a DataFrame and target column name,
+    and the direct form with features X and target values y.
+    """
+
+    if isinstance(problem_type, str):
+        X = data.drop(columns=[target])
+        y = data[target]
+        split_test_size = test_size
+        split_random_state = random_state
+        detected_problem = problem_type
+    else:
+        X = data
+        y = target
+        split_test_size = problem_type
+        split_random_state = test_size
+        detected_problem = detect_problem(y)
+
+    stratify = y if detected_problem == "classification" else None
+
+    try:
+        return train_test_split(
+            X,
+            y,
+            test_size=split_test_size,
+            random_state=split_random_state,
+            stratify=stratify,
+        )
+    except ValueError as exc:
+        if stratify is not None and "least populated classes" in str(exc):
+            return train_test_split(
+                X,
+                y,
+                test_size=split_test_size,
+                random_state=split_random_state,
+                stratify=None,
+            )
+        raise

mlcompare_dev-0.1.1/mlcompare/version.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "0.1.1"

mlcompare_dev-0.1.1/mlcompare_dev.egg-info/PKG-INFO

@@ -0,0 +1,213 @@
+Metadata-Version: 2.4
+Name: mlcompare-dev
+Version: 0.1.1
+Summary: Compare classification and regression ML models
+Author: Manish Kumar
+License: MIT
+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.4.0
+Requires-Dist: joblib>=1.3.0
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🚀 MLCompare
+
+**MLCompare** is a beginner-friendly Python library to compare multiple Machine Learning models with just a few lines of code.
+
+Instead of writing repetitive code for training and evaluating models, MLCompare automatically trains multiple algorithms, compares their performance, selects the best model, and allows prediction and model saving.
+
+---
+
+# ✨ Features
+
+- ✅ Automatic Classification & Regression Detection
+- ✅ Train Multiple ML Models
+- ✅ Compare Model Performance
+- ✅ Automatically Select Best Model
+- ✅ Predict Using Best Model
+- ✅ Save & Load Trained Model
+- ✅ Simple Beginner-Friendly API
+
+---
+
+# 📦 Installation
+
+```bash
+pip install mlcompare
+```
+
+Or install locally
+
+```bash
+pip install -e .
+```
+
+---
+
+# 📚 Supported Models
+
+## Classification
+
+- Logistic Regression
+- K-Nearest Neighbors (KNN)
+- Support Vector Machine (SVM)
+- Decision Tree
+- Random Forest
+- AdaBoost
+- Gradient Boosting
+- Extra Trees
+
+## Regression
+
+- Linear Regression
+- Ridge Regression
+- Lasso Regression
+- ElasticNet
+- Decision Tree Regressor
+- Random Forest Regressor
+- Gradient Boosting Regressor
+- Extra Trees Regressor
+
+---
+
+# 🚀 Quick Start
+
+```python
+from mlcompare import MLCompare
+import pandas as pd
+
+df = pd.read_csv("data.csv")
+
+ml = MLCompare(
+    data=df,
+    target="target"
+)
+
+results = ml.compare()
+
+print(results)
+```
+
+---
+
+# 🏆 Best Model
+
+```python
+print(ml.best_model_name)
+```
+
+---
+
+# 🔮 Prediction
+
+```python
+new_data = df.drop(columns=["target"]).head()
+
+predictions = ml.predict(new_data)
+
+print(predictions)
+```
+
+---
+
+# 💾 Save Model
+
+```python
+ml.save("best_model.pkl")
+```
+
+---
+
+# 📂 Load Model
+
+```python
+ml.load("best_model.pkl")
+```
+
+---
+
+# 📊 Example Output
+
+| Model | Accuracy |
+|--------|----------|
+| SVM | 0.95 |
+| Random Forest | 0.94 |
+| Extra Trees | 0.93 |
+| Logistic Regression | 0.91 |
+
+---
+
+# 📁 Project Structure
+
+```
+mlcompare/
+│
+├── core.py
+├── models.py
+├── metrics.py
+├── utils.py
+├── save.py
+├── version.py
+└── __init__.py
+```
+
+---
+
+# 🛠 Requirements
+
+- Python 3.10+
+- pandas
+- numpy
+- scikit-learn
+- joblib
+
+---
+
+# 📌 Roadmap
+
+Upcoming Features
+
+- Hyperparameter Tuning
+- Cross Validation
+- Feature Importance
+- Confusion Matrix
+- ROC-AUC Score
+- StandardScaler Support
+- Missing Value Handling
+- Categorical Encoding
+- XGBoost
+- LightGBM
+- CatBoost
+
+---
+
+# 🤝 Contributing
+
+Contributions are welcome!
+
+Feel free to open an Issue or submit a Pull Request.
+
+---
+
+# 📄 License
+
+MIT License
+
+---
+
+# 👨‍💻 Author
+
+**Manish Kumar**
+
+GitHub:
+https://github.com/Developer-Manish007

mlcompare_dev-0.1.1/mlcompare_dev.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+setup.py
+mlcompare/__init__.py
+mlcompare/core.py
+mlcompare/metrics.py
+mlcompare/models.py
+mlcompare/save.py
+mlcompare/utils.py
+mlcompare/version.py
+mlcompare_dev.egg-info/PKG-INFO
+mlcompare_dev.egg-info/SOURCES.txt
+mlcompare_dev.egg-info/dependency_links.txt
+mlcompare_dev.egg-info/requires.txt
+mlcompare_dev.egg-info/top_level.txt

mlcompare_dev-0.1.1/mlcompare_dev.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mlcompare_dev-0.1.1/mlcompare_dev.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pandas>=2.0.0
+numpy>=1.24.0
+scikit-learn>=1.4.0
+joblib>=1.3.0

mlcompare_dev-0.1.1/mlcompare_dev.egg-info/top_level.txt

@@ -0,0 +1 @@
+mlcompare

mlcompare_dev-0.1.1/setup.cfg

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

mlcompare_dev-0.1.1/setup.py

@@ -0,0 +1,22 @@
+from setuptools import setup, find_packages
+
+with open("README.md", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="mlcompare-dev",
+    version="0.1.1",
+    author="Manish Kumar",
+    description="Compare classification and regression ML models",
+    long_description=long_description,
+    license="MIT",
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=[
+        "pandas>=2.0.0",
+        "numpy>=1.24.0",
+        "scikit-learn>=1.4.0",
+        "joblib>=1.3.0",
+    ],
+    python_requires=">=3.10",
+)