kaizenstat 0.1.0__tar.gz

kaizenstat-0.1.0/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: kaizenstat
+Version: 0.1.0
+Summary: Zero-friction AutoML + Data Cleaning Toolkit
+Author: Masuddar Rahman
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: rich
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🚀 KaizenStat
+
+[![PyPI Version](https://img.shields.io/pypi/v/kaizenstat.svg)](https://pypi.org/project/kaizenstat/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+
+**KaizenStat** is a zero-friction data validation, automatic cleaning, and AutoML benchmarking toolkit designed to fit right into your daily data science workflow. It helps you diagnose and repair dataset issues instantly and trains baseline models to give you immediate insights.
+
+---
+
+## ✨ Features
+
+- 🔍 **`kz.audit()`**: Instantly sweep datasets for duplicates, NaNs, infs, constant columns, and target label integrity.
+- 🩹 **`kz.heal()`**: Automatically clean datasets by repairing missing targets, removing duplicates, dropping dead/constant columns, and imputing missing data using mean, median, or mode.
+- 🚀 **`kz.benchmark()`**: Auto-detects objectives (classification/regression), builds pre-processing pipelines, trains elite models (Linear/Ridge, RandomForest, Neural Networks), and ranks them on a beautiful leaderboard.
+- 💻 **CLI Interface**: Command line utility (`kz`) to audit, heal, or benchmark CSV datasets directly from the terminal.
+
+---
+
+## 📦 Installation
+
+Install KaizenStat from PyPI:
+
+```bash
+pip install kaizenstat
+```
+
+Or install it locally in editable mode for development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## 🚀 Quickstart Usage
+
+### Python API
+
+```python
+import pandas as pd
+from kaizenstat import KaizenStat
+
+# Load dataset
+df = pd.read_csv("data.csv")
+
+# 1. Audit dataset
+KaizenStat.audit(df, target_column="target")
+
+# 2. Automatically repair dataset issues
+clean_df = KaizenStat.heal(df, target_column="target", method="fill_median")
+
+# 3. Benchmark ML models
+leaderboard = KaizenStat.benchmark(clean_df, target_column="target")
+```
+
+### 💻 Command Line Interface (CLI)
+
+KaizenStat provides a powerful CLI tool named `kz` right out of the box:
+
+#### Audit a dataset:
+```bash
+kz audit data.csv --target price
+```
+
+#### Heal a dataset:
+```bash
+kz heal data.csv --target price --method fill_median -o clean_data.csv
+```
+
+#### Benchmark a dataset:
+```bash
+kz benchmark clean_data.csv --target price
+```
+
+---
+
+## 🛠 Development and Packaging
+
+Build the package using `build`:
+
+```bash
+pip install build twine
+python -m build
+```
+
+Upload to PyPI:
+
+```bash
+twine upload dist/*
+```
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.

kaizenstat-0.1.0/README.md

@@ -0,0 +1,97 @@
+# 🚀 KaizenStat
+
+[![PyPI Version](https://img.shields.io/pypi/v/kaizenstat.svg)](https://pypi.org/project/kaizenstat/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+
+**KaizenStat** is a zero-friction data validation, automatic cleaning, and AutoML benchmarking toolkit designed to fit right into your daily data science workflow. It helps you diagnose and repair dataset issues instantly and trains baseline models to give you immediate insights.
+
+---
+
+## ✨ Features
+
+- 🔍 **`kz.audit()`**: Instantly sweep datasets for duplicates, NaNs, infs, constant columns, and target label integrity.
+- 🩹 **`kz.heal()`**: Automatically clean datasets by repairing missing targets, removing duplicates, dropping dead/constant columns, and imputing missing data using mean, median, or mode.
+- 🚀 **`kz.benchmark()`**: Auto-detects objectives (classification/regression), builds pre-processing pipelines, trains elite models (Linear/Ridge, RandomForest, Neural Networks), and ranks them on a beautiful leaderboard.
+- 💻 **CLI Interface**: Command line utility (`kz`) to audit, heal, or benchmark CSV datasets directly from the terminal.
+
+---
+
+## 📦 Installation
+
+Install KaizenStat from PyPI:
+
+```bash
+pip install kaizenstat
+```
+
+Or install it locally in editable mode for development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## 🚀 Quickstart Usage
+
+### Python API
+
+```python
+import pandas as pd
+from kaizenstat import KaizenStat
+
+# Load dataset
+df = pd.read_csv("data.csv")
+
+# 1. Audit dataset
+KaizenStat.audit(df, target_column="target")
+
+# 2. Automatically repair dataset issues
+clean_df = KaizenStat.heal(df, target_column="target", method="fill_median")
+
+# 3. Benchmark ML models
+leaderboard = KaizenStat.benchmark(clean_df, target_column="target")
+```
+
+### 💻 Command Line Interface (CLI)
+
+KaizenStat provides a powerful CLI tool named `kz` right out of the box:
+
+#### Audit a dataset:
+```bash
+kz audit data.csv --target price
+```
+
+#### Heal a dataset:
+```bash
+kz heal data.csv --target price --method fill_median -o clean_data.csv
+```
+
+#### Benchmark a dataset:
+```bash
+kz benchmark clean_data.csv --target price
+```
+
+---
+
+## 🛠 Development and Packaging
+
+Build the package using `build`:
+
+```bash
+pip install build twine
+python -m build
+```
+
+Upload to PyPI:
+
+```bash
+twine upload dist/*
+```
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.

kaizenstat-0.1.0/kaizenstat/__init__.py

@@ -0,0 +1,3 @@
+from .core import KaizenStat
+
+__all__ = ["KaizenStat"]

kaizenstat-0.1.0/kaizenstat/cli.py

@@ -0,0 +1,53 @@
+import argparse
+import sys
+import pandas as pd
+from kaizenstat.core import KaizenStat
+from rich.console import Console
+
+console = Console()
+
+def main():
+    parser = argparse.ArgumentParser(description="KaizenStat CLI - Zero-friction AutoML & Data Cleaning Toolkit")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # Audit command
+    audit_parser = subparsers.add_parser("audit", help="Audit dataset for potential issues")
+    audit_parser.add_argument("csv_path", help="Path to the CSV dataset file")
+    audit_parser.add_argument("--target", help="Optional name of the target column", default=None)
+
+    # Heal command
+    heal_parser = subparsers.add_parser("heal", help="Clean/heal dataset automatically")
+    heal_parser.add_argument("csv_path", help="Path to the CSV dataset file")
+    heal_parser.add_argument("--target", help="Optional name of the target column", default=None)
+    heal_parser.add_argument("--method", choices=["fill_median", "fill_mean", "drop_rows"], default="fill_median", help="Method used for healing missing values")
+    heal_parser.add_argument("-o", "--output", help="Path to output the healed CSV. Defaults to '<filename>_healed.csv'", default=None)
+
+    # Benchmark command
+    benchmark_parser = subparsers.add_parser("benchmark", help="Benchmark AutoML models on a target column")
+    benchmark_parser.add_argument("csv_path", help="Path to the CSV dataset file")
+    benchmark_parser.add_argument("--target", required=True, help="Name of the target column")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        df = pd.read_csv(args.csv_path)
+    except Exception as e:
+        console.print(f"[bold red]Error loading dataset:[/] {e}")
+        sys.exit(1)
+
+    if args.command == "audit":
+        KaizenStat.audit(df, target_column=args.target)
+    elif args.command == "heal":
+        healed_df = KaizenStat.heal(df, target_column=args.target, method=args.method)
+        output_path = args.output or (args.csv_path[:-4] + "_healed.csv" if args.csv_path.endswith(".csv") else args.csv_path + "_healed")
+        healed_df.to_csv(output_path, index=False)
+        console.print(f"[bold green]Saved healed dataset to:[/] {output_path}")
+    elif args.command == "benchmark":
+        KaizenStat.benchmark(df, target_column=args.target)
+
+if __name__ == "__main__":
+    main()

kaizenstat-0.1.0/kaizenstat/core.py

@@ -0,0 +1,282 @@
+# -*- coding: utf-8 -*-
+"""
+KAIZENSTAT (v3.0): The Zero-Friction 'Daily Friend' Pipeline.
+"""
+
+import time
+from typing import Optional, Dict, List
+
+import numpy as np
+import pandas as pd
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.model_selection import train_test_split
+from sklearn.linear_model import LogisticRegression, Ridge
+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
+from sklearn.neural_network import MLPClassifier, MLPRegressor
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import accuracy_score, f1_score, r2_score, mean_absolute_error
+
+# Initialize Rich console
+console = Console()
+
+class KaizenStat:
+    """
+    KAIZENSTAT (v3.0): The Zero-Friction 'Daily Friend' Pipeline.
+    """
+
+    # =========================================================================
+    # MODULE 1: THE VALIDATOR (kz.audit)
+    # =========================================================================
+    @staticmethod
+    def audit(df: pd.DataFrame, target_column: Optional[str] = None) -> None:
+        """
+        Runs a comprehensive diagnostic sweep over the dataframe to catch
+        hidden data corruption, NaNs, infinite values, and variance issues.
+        """
+        console.print(Panel.fit("[bold cyan]🔍 KAIZENSTAT AUDIT: Diagnostic Sweep[/bold cyan]", border_style="cyan"))
+
+        table = Table(show_header=True, header_style="bold white", border_style="bright_black")
+        table.add_column("Diagnostic Check", style="cyan")
+        table.add_column("Status / Findings", justify="left")
+
+        table.add_row("Matrix Dimensions", f"{df.shape[0]} Rows × {df.shape[1]} Columns")
+
+        dupes = df.duplicated().sum()
+        status = f"[red]Failed: {dupes} duplicate rows found[/red]" if dupes > 0 else "[green]Passed[/green]"
+        table.add_row("Duplicate Rows", status)
+
+        total_missing = df.isna().sum().sum()
+        if total_missing > 0:
+            missing_cols = df.columns[df.isna().any()].tolist()
+            table.add_row("Missing Values (NaNs)", f"[red]Failed: {total_missing} NaNs across {len(missing_cols)} columns[/red]")
+        else:
+            table.add_row("Missing Values (NaNs)", "[green]Passed[/green]")
+
+        num_cols = df.select_dtypes(include=[np.number])
+        infs = np.isinf(num_cols).sum().sum() if not num_cols.empty else 0
+        table.add_row("Infinite Values (inf)", f"[red]Failed: {infs} infs found[/red]" if infs > 0 else "[green]Passed[/green]")
+
+        dead_cols = [col for col in df.columns if df[col].nunique() <= 1]
+        table.add_row("Constant Columns (No Variance)", f"[yellow]Warning: {len(dead_cols)} found {dead_cols}[/yellow]" if dead_cols else "[green]Passed[/green]")
+
+        if target_column:
+            if target_column not in df.columns:
+                table.add_row("Target Variable", f"[bold red]CRITICAL: '{target_column}' not found in dataset![/bold red]")
+            else:
+                target_nans = df[target_column].isna().sum()
+                table.add_row("Target Variable Integrity", f"[red]Failed: {target_nans} missing labels[/red]" if target_nans > 0 else "[green]Passed[/green]")
+
+        console.print(table)
+        console.print("[dim]Audit complete. Proceed to kz.heal() to automatically repair failed checks.[/dim]\n")
+
+    # =========================================================================
+    # MODULE 2: THE ADVANCED HEALER (kz.heal)
+    # =========================================================================
+    @staticmethod
+    def heal(df: pd.DataFrame, target_column: Optional[str] = None, method: str = "fill_median") -> pd.DataFrame:
+        """
+        Intelligently repairs the dataframe with user-defined control.
+        Available methods: "fill_median", "fill_mean", or "drop_rows".
+        """
+        console.print(f"[bold green]🩹 KAIZENSTAT HEALER: Initiating Auto-Repair (Strategy: {method.upper()})[/bold green]")
+        clean_df = df.copy()
+
+        if target_column and target_column in clean_df.columns:
+            target_missing = clean_df[target_column].isna().sum()
+            if target_missing > 0:
+                clean_df = clean_df.dropna(subset=[target_column])
+                console.print(f"  [green]✓[/green] Dropped {target_missing} rows where target '{target_column}' was missing.")
+
+        dupes = clean_df.duplicated().sum()
+        if dupes > 0:
+            clean_df = clean_df.drop_duplicates()
+            console.print(f"  [green]✓[/green] Removed {dupes} duplicated rows.")
+
+        num_cols = clean_df.select_dtypes(include=[np.number]).columns
+        clean_df[num_cols] = clean_df[num_cols].replace([np.inf, -np.inf], np.nan)
+
+        for col in list(clean_df.columns):
+            if clean_df[col].isna().mean() > 0.90:
+                clean_df = clean_df.drop(columns=[col])
+                console.print(f"  [green]✓[/green] Dropped '{col}' (Over 90% missing data).")
+            elif clean_df[col].nunique() <= 1 and col != target_column:
+                clean_df = clean_df.drop(columns=[col])
+                console.print(f"  [green]✓[/green] Dropped '{col}' (Zero variance / Constant feature).")
+
+        if method == "drop_rows":
+            before_drop = len(clean_df)
+            clean_df = clean_df.dropna()
+            rows_dropped = before_drop - len(clean_df)
+            console.print(f"  [bold yellow]⚠ Strict Mode Active:[/bold yellow] Dropped {rows_dropped} rows containing NaNs.")
+
+        elif method in ["fill_mean", "fill_median"]:
+            numeric_cols = clean_df.select_dtypes(include=[np.number]).columns
+            if len(numeric_cols) > 0:
+                if method == "fill_mean":
+                    clean_df[numeric_cols] = clean_df[numeric_cols].fillna(clean_df[numeric_cols].mean())
+                    console.print("  [green]✓[/green] Filled numeric NaNs using [bold]Mean (Average)[/bold].")
+                else:
+                    clean_df[numeric_cols] = clean_df[numeric_cols].fillna(clean_df[numeric_cols].median())
+                    console.print("  [green]✓[/green] Filled numeric NaNs using [bold]Median[/bold].")
+
+            cat_cols = clean_df.select_dtypes(exclude=[np.number]).columns
+            for col in cat_cols:
+                mode_val = clean_df[col].mode()[0] if not clean_df[col].mode().empty else "Unknown"
+                clean_df[col] = clean_df[col].fillna(mode_val)
+            if len(cat_cols) > 0:
+                console.print("  [green]✓[/green] Filled categorical strings using [bold]Mode[/bold].")
+        else:
+            raise ValueError(f"Unknown healing method: '{method}'. Choose 'fill_median', 'fill_mean', or 'drop_rows'.")
+
+        console.print("  [bold green]✓ Dataset is fully healed and ready for modeling.[/bold green]\n")
+        return clean_df
+
+    # =========================================================================
+    # MODULE 3: THE FITTER (kz.benchmark)
+    # =========================================================================
+    @staticmethod
+    def benchmark(df: pd.DataFrame, target_column: str, overrides: Optional[Dict[str, Dict]] = None) -> pd.DataFrame:
+        """
+        Auto-detects the objective, builds preprocessing pipelines, applies user
+        configuration overrides, and ranks elite models in a single sweep.
+        """
+        console.print(Panel.fit("[bold magenta]🚀 KAIZENSTAT AUTO-ML: Fitter & Tuner[/bold magenta]", border_style="magenta"))
+
+        if target_column not in df.columns:
+            raise ValueError(f"Target column '{target_column}' not found.")
+
+        X = df.drop(columns=[target_column])
+        y = df[target_column]
+
+        is_classification = False
+        if y.dtype == 'object' or y.nunique() < (len(y) * 0.05):
+            is_classification = True
+
+        task_str = "CLASSIFICATION" if is_classification else "REGRESSION"
+        console.print(f"[dim]Detected Objective: [bold gold1]{task_str}[/bold gold1][/dim]\n")
+
+        num_features = X.select_dtypes(include=[np.number]).columns
+        cat_features = X.select_dtypes(exclude=[np.number]).columns
+
+        preprocessor = ColumnTransformer(transformers=[
+            ('num', StandardScaler(), num_features),
+            ('cat', OneHotEncoder(handle_unknown='ignore', sparse_output=False), cat_features)
+        ])
+
+        overrides = overrides or {}
+        if is_classification:
+            models = {
+                "Linear": LogisticRegression(**overrides.get("Linear", {"max_iter": 1000})),
+                "RandomForest": RandomForestClassifier(**overrides.get("RandomForest", {"n_estimators": 50, "random_state": 42})),
+                "NeuralNet": MLPClassifier(**overrides.get("NeuralNet", {"max_iter": 500, "hidden_layer_sizes": (64, 32), "random_state": 42}))
+            }
+        else:
+            models = {
+                "Linear": Ridge(**overrides.get("Linear", {})),
+                "RandomForest": RandomForestRegressor(**overrides.get("RandomForest", {"n_estimators": 50, "random_state": 42})),
+                "NeuralNet": MLPRegressor(**overrides.get("NeuralNet", {"max_iter": 500, "hidden_layer_sizes": (64, 32), "random_state": 42}))
+            }
+
+        X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+        leaderboard_data = []
+
+        for name, model in models.items():
+            pipeline = Pipeline(steps=[('preprocessor', preprocessor), ('model', model)])
+
+            try:
+                start_time = time.time()
+                pipeline.fit(X_train, y_train)
+                latency = time.time() - start_time
+
+                preds = pipeline.predict(X_test)
+
+                if is_classification:
+                    primary = accuracy_score(y_test, preds)
+                    secondary = f"F1: {f1_score(y_test, preds, average='weighted', zero_division=0):.3f}"
+                else:
+                    primary = r2_score(y_test, preds)
+                    secondary = f"MAE: {mean_absolute_error(y_test, preds):.2f}"
+
+                leaderboard_data.append({
+                    "Model": name, "Primary Score": primary, "Secondary Metric": secondary,
+                    "Time (s)": latency, "Status": "[green]SUCCESS[/green]"
+                })
+            except Exception as e:
+                leaderboard_data.append({
+                    "Model": name, "Primary Score": 0.0, "Secondary Metric": "N/A",
+                    "Time (s)": 0.0, "Status": f"[red]FAIL: {str(e)[:15]}[/red]"
+                })
+
+        df_results = pd.DataFrame(leaderboard_data).sort_values(by="Primary Score", ascending=False).reset_index(drop=True)
+
+        table = Table(title="🏆 MODEL LEADERBOARD", border_style="bright_black")
+        table.add_column("Rank", justify="center")
+        table.add_column("Architecture", style="cyan")
+        metric_name = "Accuracy" if is_classification else "R² Score"
+        table.add_column(metric_name, justify="right", style="green")
+        table.add_column("Secondary", justify="right")
+        table.add_column("Latency", justify="right", style="yellow")
+        table.add_column("Status", justify="center")
+
+        for idx, row in df_results.iterrows():
+            score_fmt = f"{row['Primary Score']*100:.2f}%" if is_classification else f"{row['Primary Score']:.4f}"
+            table.add_row(f"#{idx + 1}", row["Model"], score_fmt, row["Secondary Metric"], f"{row['Time (s)']:.3f}s", row["Status"])
+
+        console.print(table)
+        return df_results
+
+
+# =========================================================================
+# WORKFLOW EXECUTION (The "Ample Data" Enterprise Test)
+# =========================================================================
+if __name__ == "__main__":
+    from sklearn.datasets import make_classification
+
+    console.print("\n[bold yellow]Generating 15,000 rows of synthetic Enterprise Data...[/bold yellow]\n")
+
+    # 1. Generate a massive, mathematically complex dataset
+    X_raw, y_raw = make_classification(
+        n_samples=15000,
+        n_features=12,
+        n_informative=8,
+        random_state=42
+    )
+
+    # 2. Convert to DataFrame with realistic column names
+    cols = [f"sensor_metric_{i}" for i in range(10)] + ['user_category', 'region_code']
+    df_massive = pd.DataFrame(X_raw, columns=cols)
+
+    # Make some columns categorical strings to test the preprocessor
+    df_massive['user_category'] = np.random.choice(['Premium', 'Standard', 'Free'], size=15000)
+    df_massive['region_code'] = np.random.choice(['US', 'EU', 'ASIA'], size=15000)
+
+    # 3. Add the target variable
+    df_massive['target_conversion'] = y_raw
+
+    # 4. Inject Realistic Enterprise Data Corruption (The problems to heal!)
+    df_massive.loc[100:500, 'sensor_metric_2'] = np.nan       # Missing data
+    df_massive.loc[8000:8100, 'sensor_metric_5'] = np.inf     # Math errors
+    df_massive.loc[12000:12050, 'target_conversion'] = np.nan # Missing targets
+
+    # --- RUN KAIZENSTAT ---
+    # Audit will catch the 15,000 row scale and the injected errors
+    KaizenStat.audit(df_massive, target_column="target_conversion")
+
+    # Healer will safely patch the massive dataset
+    df_clean = KaizenStat.heal(df_massive, target_column="target_conversion", method="fill_median")
+
+    # Power user tweaks for the deep learning and ensemble networks
+    my_tweaks = {
+        "RandomForest": {"n_estimators": 150, "max_depth": 15, "n_jobs": -1},
+        "NeuralNet": {"hidden_layer_sizes": (128, 64), "max_iter": 300}
+    }
+
+    # Benchmark will now have ample data to learn and generate a real leaderboard
+    leaderboard = KaizenStat.benchmark(df_clean, target_column="target_conversion", overrides=my_tweaks)

kaizenstat-0.1.0/kaizenstat.egg-info/PKG-INFO

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: kaizenstat
+Version: 0.1.0
+Summary: Zero-friction AutoML + Data Cleaning Toolkit
+Author: Masuddar Rahman
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: rich
+Dynamic: author
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🚀 KaizenStat
+
+[![PyPI Version](https://img.shields.io/pypi/v/kaizenstat.svg)](https://pypi.org/project/kaizenstat/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python Version](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/downloads/)
+
+**KaizenStat** is a zero-friction data validation, automatic cleaning, and AutoML benchmarking toolkit designed to fit right into your daily data science workflow. It helps you diagnose and repair dataset issues instantly and trains baseline models to give you immediate insights.
+
+---
+
+## ✨ Features
+
+- 🔍 **`kz.audit()`**: Instantly sweep datasets for duplicates, NaNs, infs, constant columns, and target label integrity.
+- 🩹 **`kz.heal()`**: Automatically clean datasets by repairing missing targets, removing duplicates, dropping dead/constant columns, and imputing missing data using mean, median, or mode.
+- 🚀 **`kz.benchmark()`**: Auto-detects objectives (classification/regression), builds pre-processing pipelines, trains elite models (Linear/Ridge, RandomForest, Neural Networks), and ranks them on a beautiful leaderboard.
+- 💻 **CLI Interface**: Command line utility (`kz`) to audit, heal, or benchmark CSV datasets directly from the terminal.
+
+---
+
+## 📦 Installation
+
+Install KaizenStat from PyPI:
+
+```bash
+pip install kaizenstat
+```
+
+Or install it locally in editable mode for development:
+
+```bash
+pip install -e .
+```
+
+---
+
+## 🚀 Quickstart Usage
+
+### Python API
+
+```python
+import pandas as pd
+from kaizenstat import KaizenStat
+
+# Load dataset
+df = pd.read_csv("data.csv")
+
+# 1. Audit dataset
+KaizenStat.audit(df, target_column="target")
+
+# 2. Automatically repair dataset issues
+clean_df = KaizenStat.heal(df, target_column="target", method="fill_median")
+
+# 3. Benchmark ML models
+leaderboard = KaizenStat.benchmark(clean_df, target_column="target")
+```
+
+### 💻 Command Line Interface (CLI)
+
+KaizenStat provides a powerful CLI tool named `kz` right out of the box:
+
+#### Audit a dataset:
+```bash
+kz audit data.csv --target price
+```
+
+#### Heal a dataset:
+```bash
+kz heal data.csv --target price --method fill_median -o clean_data.csv
+```
+
+#### Benchmark a dataset:
+```bash
+kz benchmark clean_data.csv --target price
+```
+
+---
+
+## 🛠 Development and Packaging
+
+Build the package using `build`:
+
+```bash
+pip install build twine
+python -m build
+```
+
+Upload to PyPI:
+
+```bash
+twine upload dist/*
+```
+
+---
+
+## 📄 License
+
+Distributed under the MIT License. See `LICENSE` for more information.

kaizenstat-0.1.0/kaizenstat.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+setup.py
+kaizenstat/__init__.py
+kaizenstat/cli.py
+kaizenstat/core.py
+kaizenstat.egg-info/PKG-INFO
+kaizenstat.egg-info/SOURCES.txt
+kaizenstat.egg-info/dependency_links.txt
+kaizenstat.egg-info/entry_points.txt
+kaizenstat.egg-info/requires.txt
+kaizenstat.egg-info/top_level.txt

kaizenstat-0.1.0/kaizenstat.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

kaizenstat-0.1.0/kaizenstat.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kz = kaizenstat.cli:main

kaizenstat-0.1.0/kaizenstat.egg-info/requires.txt

@@ -0,0 +1,4 @@
+pandas
+numpy
+scikit-learn
+rich

kaizenstat-0.1.0/kaizenstat.egg-info/top_level.txt

@@ -0,0 +1 @@
+kaizenstat

kaizenstat-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

kaizenstat-0.1.0/setup.cfg

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

kaizenstat-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="kaizenstat",
+    version="0.1.0",
+    author="Masuddar Rahman",
+    description="Zero-friction AutoML + Data Cleaning Toolkit",
+    long_description=open("README.md").read() if open("README.md") else "",
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    install_requires=[
+        "pandas",
+        "numpy",
+        "scikit-learn",
+        "rich"
+    ],
+    python_requires=">=3.8",
+    entry_points={
+        'console_scripts': [
+            'kz=kaizenstat.cli:main',
+        ],
+    },
+)