data-autoeda 0.1.1__tar.gz

data_autoeda-0.1.1/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: data-autoeda
+Version: 0.1.1
+Summary: Automatic Exploratory Data Analysis, Cleaning, Validation, Visualization, and Smart Insights on ANY CSV dataset.
+Author: shubham kumar
+License: MIT
+Project-URL: Homepage, https://github.com/Shu40/AutoEDA/
+Project-URL: Repository, https://github.com/Shu40/AutoEDA/
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=10.0.0
+
+# AutoEDA
+
+A production-ready Python package that performs automatic Exploratory Data Analysis (EDA), Data Cleaning, Data Validation, Visualization, and Smart Insights on ANY CSV dataset.
+
+## Features
+- **Dynamic Analysis**: Automatically detects numerical, categorical, boolean, and datetime columns.
+- **Smart Cleaning**: Handles missing values, removes duplicates, and optimizes datatypes automatically.
+- **Visualizations**: Automatically generates relevant charts using Matplotlib and Seaborn.
+- **Smart Insights**: Generates English observations based on statistical findings.
+- **Rich Terminal UI**: Beautiful, organized CLI reports.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+### Python API
+
+```python
+from autoeda import analyze
+
+# Complete analysis
+analyze("data.csv")
+
+# Only clean data
+# analyze("data.csv", mode="clean")
+```
+
+### CLI
+
+```bash
+# Complete analysis
+autoeda data.csv
+
+# Specific modes
+autoeda data.csv --clean
+autoeda data.csv --visualize
+autoeda data.csv --all
+```

data_autoeda-0.1.1/README.md

@@ -0,0 +1,42 @@
+# AutoEDA
+
+A production-ready Python package that performs automatic Exploratory Data Analysis (EDA), Data Cleaning, Data Validation, Visualization, and Smart Insights on ANY CSV dataset.
+
+## Features
+- **Dynamic Analysis**: Automatically detects numerical, categorical, boolean, and datetime columns.
+- **Smart Cleaning**: Handles missing values, removes duplicates, and optimizes datatypes automatically.
+- **Visualizations**: Automatically generates relevant charts using Matplotlib and Seaborn.
+- **Smart Insights**: Generates English observations based on statistical findings.
+- **Rich Terminal UI**: Beautiful, organized CLI reports.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+### Python API
+
+```python
+from autoeda import analyze
+
+# Complete analysis
+analyze("data.csv")
+
+# Only clean data
+# analyze("data.csv", mode="clean")
+```
+
+### CLI
+
+```bash
+# Complete analysis
+autoeda data.csv
+
+# Specific modes
+autoeda data.csv --clean
+autoeda data.csv --visualize
+autoeda data.csv --all
+```

data_autoeda-0.1.1/autoeda/__init__.py

@@ -0,0 +1,3 @@
+from .cli import analyze
+
+__all__ = ["analyze"]

data_autoeda-0.1.1/autoeda/analyzer.py

@@ -0,0 +1,288 @@
+import pandas as pd
+import numpy as np
+from rich.table import Table
+from rich.progress import track
+from .utils import console, print_section, print_warning
+
+def run_analysis(df: pd.DataFrame, smart_mode: bool = False):
+    steps = [
+        (_dataset_overview, "Dataset Overview"),
+        (_column_analysis, "Column Analysis"),
+        (_null_analysis, "Null Value Analysis"),
+        (_duplicate_analysis, "Duplicate Analysis"),
+        (_unique_value_analysis, "Unique Value Analysis"),
+        (_value_counts_analysis, "Value Counts Analysis"),
+        (_numerical_analysis, "Numerical Analysis"),
+        (_outlier_analysis, "Outlier Analysis"),
+        (_correlation_analysis, "Correlation Analysis"),
+        (_datetime_analysis, "Datetime Analysis"),
+    ]
+    
+    if smart_mode:
+        console.print("[yellow]Running analysis in Smart Mode... Some heavy computations may be optimized or skipped.[/yellow]")
+        
+    for func, name in track(steps, description="Running Analysis Modules..."):
+        try:
+            if func in [_unique_value_analysis, _value_counts_analysis, _correlation_analysis]:
+                func(df, smart_mode)
+            else:
+                func(df)
+        except Exception as e:
+            console.print(f"[red]Error in {name}: {e}[/red]")
+
+def _dataset_overview(df: pd.DataFrame):
+    print_section("Dataset Overview")
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Metric", style="dim", width=20)
+    table.add_column("Value")
+    
+    table.add_row("Dataset Shape", f"{df.shape[0]} Rows, {df.shape[1]} Columns")
+    table.add_row("Total Rows", str(df.shape[0]))
+    table.add_row("Total Columns", str(df.shape[1]))
+    table.add_row("Column Names", ", ".join(df.columns.astype(str).tolist()))
+    
+    memory_mb = df.memory_usage(deep=True).sum() / (1024 * 1024)
+    table.add_row("Memory Usage", f"{memory_mb:.2f} MB")
+    
+    console.print(table)
+    
+    print_section("First 5 Rows")
+    console.print(df.head(5).to_string())
+    print_section("Last 5 Rows")
+    console.print(df.tail(5).to_string())
+
+def _column_analysis(df: pd.DataFrame):
+    print_section("Column Analysis")
+    
+    num_cols = df.select_dtypes(include=['number']).columns.tolist()
+    cat_cols = df.select_dtypes(include=['object', 'category']).columns.tolist()
+    bool_cols = df.select_dtypes(include=['bool']).columns.tolist()
+    dt_cols = df.select_dtypes(include=['datetime']).columns.tolist()
+    
+    console.print(f"[bold]Numerical Columns:[/bold] {len(num_cols)} -> {num_cols}")
+    console.print(f"[bold]Categorical Columns:[/bold] {len(cat_cols)} -> {cat_cols}")
+    console.print(f"[bold]Boolean Columns:[/bold] {len(bool_cols)} -> {bool_cols}")
+    console.print(f"[bold]Datetime Columns:[/bold] {len(dt_cols)} -> {dt_cols}")
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Column Name")
+    table.add_column("Data Type")
+    table.add_column("Total Values")
+    table.add_column("Null Values")
+    table.add_column("Null %")
+    table.add_column("Unique Values")
+    
+    total_rows = len(df)
+    for col in df.columns:
+        null_count = df[col].isnull().sum()
+        null_pct = (null_count / total_rows) * 100
+        table.add_row(
+            str(col),
+            str(df[col].dtype),
+            str(total_rows - null_count),
+            str(null_count),
+            f"{null_pct:.2f}%",
+            str(df[col].nunique())
+        )
+    console.print(table)
+
+def _null_analysis(df: pd.DataFrame):
+    print_section("Null Value Analysis")
+    total_nulls = df.isnull().sum().sum()
+    console.print(f"[bold]Total Null Values:[/bold] {total_nulls}")
+    
+    if total_nulls > 0:
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Column Name")
+        table.add_column("Null Values")
+        table.add_column("Null Percentage")
+        
+        for col in df.columns:
+            nc = df[col].isnull().sum()
+            if nc > 0:
+                table.add_row(str(col), str(nc), f"{(nc/len(df))*100:.2f}%")
+        console.print(table)
+
+def _duplicate_analysis(df: pd.DataFrame):
+    print_section("Duplicate Analysis")
+    dup_count = df.duplicated().sum()
+    dup_pct = (dup_count / len(df)) * 100
+    console.print(f"[bold]Total Duplicate Rows:[/bold] {dup_count}")
+    console.print(f"[bold]Duplicate Percentage:[/bold] {dup_pct:.2f}%")
+    
+    if dup_count > 0:
+        console.print("Sample Duplicates:")
+        console.print(df[df.duplicated(keep=False)].head(5).to_string())
+
+def _unique_value_analysis(df: pd.DataFrame, smart_mode: bool = False):
+    print_section("Unique Value Analysis")
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Column Name")
+    table.add_column("Unique Count")
+    table.add_column("Sample Unique Values")
+    
+    for col in df.columns:
+        if smart_mode and str(df[col].dtype) == 'object':
+            table.add_row(str(col), "Skipped (Smart Mode)", "...")
+            continue
+            
+        uniques = df[col].dropna().unique()
+        sample = ", ".join([str(x) for x in uniques[:5]])
+        if len(uniques) > 5:
+            sample += "..."
+        table.add_row(str(col), str(len(uniques)), sample)
+    console.print(table)
+
+def _value_counts_analysis(df: pd.DataFrame, smart_mode: bool = False):
+    print_section("Value Counts Analysis (Categorical)")
+    cat_cols = df.select_dtypes(include=['object', 'category']).columns
+    for col in cat_cols:
+        if smart_mode and df[col].nunique() > 100:
+            console.print(f"\n[bold underline]{col}[/bold underline] - [yellow]Skipped (Too many categories for Smart Mode)[/yellow]")
+            continue
+            
+        console.print(f"\n[bold underline]{col}[/bold underline]")
+        vc = df[col].value_counts()
+        vcp = df[col].value_counts(normalize=True) * 100
+        
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Value")
+        table.add_column("Count")
+        table.add_column("Frequency %")
+        
+        for val, count in vc.head(10).items():
+            pct = vcp[val]
+            table.add_row(str(val), str(count), f"{pct:.2f}%")
+            
+        if len(vc) > 10:
+            table.add_row("...", "...", "...")
+        console.print(table)
+
+def _numerical_analysis(df: pd.DataFrame):
+    print_section("Numerical Analysis")
+    num_cols = df.select_dtypes(include=['number']).columns
+    if len(num_cols) == 0:
+        console.print("No numerical columns found.")
+        return
+        
+    for col in num_cols:
+        console.print(f"\n[bold underline]{col}[/bold underline]")
+        s = df[col].dropna()
+        if s.empty:
+            continue
+        
+        table = Table(show_header=False)
+        table.add_column("Stat", style="dim")
+        table.add_column("Value")
+        
+        table.add_row("Count", str(len(s)))
+        table.add_row("Mean", f"{s.mean():.4f}")
+        table.add_row("Median", f"{s.median():.4f}")
+        mode_val = s.mode()
+        table.add_row("Mode", str(mode_val.iloc[0]) if not mode_val.empty else "N/A")
+        table.add_row("Std Dev", f"{s.std():.4f}")
+        table.add_row("Variance", f"{s.var():.4f}")
+        table.add_row("Min", f"{s.min():.4f}")
+        table.add_row("Max", f"{s.max():.4f}")
+        table.add_row("Range", f"{(s.max() - s.min()):.4f}")
+        table.add_row("Q1 (25%)", f"{s.quantile(0.25):.4f}")
+        table.add_row("Q3 (75%)", f"{s.quantile(0.75):.4f}")
+        table.add_row("Skewness", f"{s.skew():.4f}")
+        table.add_row("Kurtosis", f"{s.kurtosis():.4f}")
+        
+        console.print(table)
+
+def _outlier_analysis(df: pd.DataFrame):
+    print_section("Outlier Analysis (IQR Method)")
+    num_cols = df.select_dtypes(include=['number']).columns
+    
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Column")
+    table.add_column("Outliers Count")
+    table.add_column("Outliers Percentage")
+    
+    has_outliers = False
+    for col in num_cols:
+        s = df[col].dropna()
+        if s.empty: continue
+        q1 = s.quantile(0.25)
+        q3 = s.quantile(0.75)
+        iqr = q3 - q1
+        lower_bound = q1 - 1.5 * iqr
+        upper_bound = q3 + 1.5 * iqr
+        
+        outliers = s[(s < lower_bound) | (s > upper_bound)]
+        ocount = len(outliers)
+        if ocount > 0:
+            has_outliers = True
+            table.add_row(str(col), str(ocount), f"{(ocount / len(s)) * 100:.2f}%")
+            
+    if has_outliers:
+        console.print(table)
+    else:
+        console.print("No outliers detected based on IQR method.")
+
+def _correlation_analysis(df: pd.DataFrame, smart_mode: bool = False):
+    print_section("Correlation Analysis")
+    num_df = df.select_dtypes(include=['number'])
+    
+    if smart_mode and len(num_df.columns) > 50:
+        console.print("[yellow]Skipping full correlation matrix calculation for >50 columns in Smart Mode.[/yellow]")
+        return
+        
+    if len(num_df.columns) < 2:
+        console.print("Not enough numerical columns for correlation.")
+        return
+        
+    corr = num_df.corr()
+    console.print(corr.to_string())
+    
+    # Strong correlations
+    strong_pos = []
+    strong_neg = []
+    
+    for i in range(len(corr.columns)):
+        for j in range(i+1, len(corr.columns)):
+            val = corr.iloc[i, j]
+            if pd.notna(val):
+                if val >= 0.7:
+                    strong_pos.append(f"{corr.columns[i]} & {corr.columns[j]}: {val:.2f}")
+                elif val <= -0.7:
+                    strong_neg.append(f"{corr.columns[i]} & {corr.columns[j]}: {val:.2f}")
+                    
+    if strong_pos:
+        console.print("\n[bold green]Strong Positive Correlations (>0.7):[/bold green]")
+        for sp in strong_pos:
+            console.print(f"- {sp}")
+            
+    if strong_neg:
+        console.print("\n[bold red]Strong Negative Correlations (<-0.7):[/bold red]")
+        for sn in strong_neg:
+            console.print(f"- {sn}")
+
+def _datetime_analysis(df: pd.DataFrame):
+    print_section("Datetime Analysis")
+    # Try to infer datetime if none exist but some look like dates
+    for col in df.select_dtypes(include=['object']):
+        try:
+            sample = df[col].dropna().head(10)
+            if not sample.empty:
+                pd.to_datetime(sample)
+                df[col] = pd.to_datetime(df[col], errors='coerce')
+        except Exception:
+            pass
+            
+    dt_cols = df.select_dtypes(include=['datetime']).columns
+    if len(dt_cols) == 0:
+        console.print("No datetime columns found.")
+        return
+        
+    for col in dt_cols:
+        console.print(f"\n[bold underline]{col}[/bold underline]")
+        s = df[col].dropna()
+        if s.empty: continue
+        console.print(f"Minimum Date: {s.min()}")
+        console.print(f"Maximum Date: {s.max()}")
+        console.print(f"Date Range: {s.max() - s.min()}")
+        console.print(f"Missing Dates: {df[col].isnull().sum()}")

data_autoeda-0.1.1/autoeda/cleaner.py

@@ -0,0 +1,104 @@
+import pandas as pd
+from rich.prompt import IntPrompt, Prompt, Confirm
+from .utils import console, print_section, print_info
+
+def clean_data(df: pd.DataFrame) -> pd.DataFrame:
+    cleaned_df = df.copy()
+    
+    print_section("Data Cleaning")
+    console.print(f"Before Cleaning Shape: {cleaned_df.shape}")
+    console.print(f"Before Cleaning Missing Values: {cleaned_df.isnull().sum().sum()}")
+    console.print(f"Before Cleaning Duplicate Count: {cleaned_df.duplicated().sum()}")
+    
+    cleaned_df.drop_duplicates(inplace=True)
+    
+    obj_cols = cleaned_df.select_dtypes(include=['object']).columns
+    for col in obj_cols:
+        try:
+            cleaned_df[col] = cleaned_df[col].str.strip()
+        except Exception:
+            pass
+
+    for col in cleaned_df.columns:
+        if cleaned_df[col].isnull().sum() > 0:
+            if pd.api.types.is_numeric_dtype(cleaned_df[col]):
+                median_val = cleaned_df[col].median()
+                cleaned_df[col].fillna(median_val, inplace=True)
+            elif pd.api.types.is_object_dtype(cleaned_df[col]) or pd.api.types.is_categorical_dtype(cleaned_df[col]):
+                mode_val = cleaned_df[col].mode()
+                if not mode_val.empty:
+                    cleaned_df[col].fillna(mode_val[0], inplace=True)
+
+    num_cols = cleaned_df.select_dtypes(include=['float64', 'int64']).columns
+    for col in num_cols:
+        try:
+            if 'int' in str(cleaned_df[col].dtype):
+                cleaned_df[col] = pd.to_numeric(cleaned_df[col], downcast='integer')
+            elif 'float' in str(cleaned_df[col].dtype):
+                cleaned_df[col] = pd.to_numeric(cleaned_df[col], downcast='float')
+        except Exception:
+            pass
+            
+    for col in cleaned_df.select_dtypes(include=['object']).columns:
+        try:
+            sample = cleaned_df[col].dropna().sample(min(100, len(cleaned_df[col].dropna())))
+            if not sample.empty:
+                pd.to_datetime(sample)
+                cleaned_df[col] = pd.to_datetime(cleaned_df[col], errors='coerce')
+        except Exception:
+            pass
+
+    console.print(f"\nAfter Cleaning Shape: {cleaned_df.shape}")
+    console.print(f"After Cleaning Missing Values: {cleaned_df.isnull().sum().sum()}")
+    console.print(f"After Cleaning Duplicate Count: {cleaned_df.duplicated().sum()}")
+    
+    return cleaned_df
+
+def interactive_clean(df: pd.DataFrame) -> pd.DataFrame:
+    df = df.copy()
+    while True:
+        print_section("Interactive Data Cleaning")
+        console.print("1. Remove Null Values")
+        console.print("2. Remove Duplicate Values")
+        console.print("3. Remove Categorical Columns")
+        console.print("4. Remove Specific Column")
+        console.print("5. Remove Specific Row")
+        console.print("6. Finish Cleaning")
+        
+        choice = IntPrompt.ask("Select an option", choices=["1", "2", "3", "4", "5", "6"])
+        
+        if choice == 1:
+            df.dropna(inplace=True)
+            console.print("[green]✔ Null values removed.[/green]")
+        elif choice == 2:
+            df.drop_duplicates(inplace=True)
+            console.print("[green]✔ Duplicates removed.[/green]")
+        elif choice == 3:
+            cat_cols = df.select_dtypes(include=['object', 'category']).columns
+            df.drop(columns=cat_cols, inplace=True)
+            console.print(f"[green]✔ Categorical columns removed: {list(cat_cols)}[/green]")
+        elif choice == 4:
+            col_name = Prompt.ask("Enter column name to remove")
+            if col_name in df.columns:
+                df.drop(columns=[col_name], inplace=True)
+                console.print(f"[green]✔ Column '{col_name}' removed.[/green]")
+            else:
+                console.print(f"[red]✖ Column '{col_name}' not found.[/red]")
+        elif choice == 5:
+            row_idx = IntPrompt.ask("Enter row index to remove")
+            try:
+                df.drop(index=row_idx, inplace=True)
+                console.print(f"[green]✔ Row {row_idx} removed.[/green]")
+            except Exception as e:
+                console.print(f"[red]✖ Failed to remove row: {e}[/red]")
+        elif choice == 6:
+            break
+            
+    save_data = Confirm.ask("Do you want to save this new cleaned data to a file?")
+    if save_data:
+        save_path = Prompt.ask("Enter filename", default="cleaned_data.csv")
+        df.to_csv(save_path, index=False)
+        console.print(f"[green]✔ New data saved to {save_path}[/green]")
+        
+    return df
+

data_autoeda-0.1.1/autoeda/cli.py

@@ -0,0 +1,94 @@
+import click
+import sys
+import time
+from .validator import load_and_validate
+from .analyzer import run_analysis
+from .cleaner import clean_data
+from .visualizer import generate_visualizations
+from .insights import generate_insights
+from .utils import print_header, print_section, print_info
+
+@click.command()
+@click.argument('file_path', type=click.Path(exists=True))
+@click.option('--clean', is_flag=True, help='Only perform data cleaning')
+@click.option('--visualize', is_flag=True, help='Only perform data visualization')
+@click.option('--all', 'run_all', is_flag=True, help='Run all modules (default behavior)')
+def cli(file_path, clean, visualize, run_all):
+    """AutoEDA: Automatic Exploratory Data Analysis & Cleaning"""
+    analyze(file_path, clean, visualize, run_all)
+
+def analyze(file_path, clean=False, visualize=False, run_all=False):
+    # If no flags are provided, run all by default
+    if not clean and not visualize:
+        run_all = True
+        
+    print_header("AutoEDA Complete Analysis Report")
+    start_time = time.time()
+    
+    try:
+        df, smart_mode = load_and_validate(file_path)
+    except Exception as e:
+        click.secho(f"Error loading file: {e}", fg='red')
+        sys.exit(1)
+        
+    if smart_mode:
+        from .utils import console
+        console.print("\n[bold yellow]Large Dataset Detected[/bold yellow]")
+        console.print(f"Rows: {len(df):,}")
+        console.print(f"Columns: {len(df.columns)}")
+        console.print("[bold green]Optimization Mode: Enabled[/bold green]")
+        
+    if clean and not run_all:
+        # Only cleaning
+        print_section("Data Cleaning")
+        df = clean_data(df)
+        print_info("Cleaning complete.")
+        return df
+        
+    while True:
+        if run_all:
+            print_info(f"Analyzing dataset...")
+            run_analysis(df, smart_mode)
+            
+            # Insights
+            print_section("Insights")
+            insights = generate_insights(df)
+            for idx, insight in enumerate(insights, 1):
+                print_info(f"{idx}. {insight}")
+                
+        if run_all or visualize:
+            print_section("Visualization")
+            generate_visualizations(df, smart_mode)
+            print_info("Visualizations generated.")
+            
+        if run_all:
+            from rich.prompt import Confirm
+            do_clean = Confirm.ask("\nDo you want to proceed to interactive data cleaning?")
+            if do_clean:
+                from .cleaner import interactive_clean
+                df = interactive_clean(df)
+                
+                do_next = Confirm.ask("\nDo you want to run the complete analysis again on the new data?")
+                if do_next:
+                    continue
+                else:
+                    break
+            else:
+                break
+        else:
+            break
+
+    end_time = time.time()
+    from rich.console import Console
+    console = Console()
+    console.print(f"\n[bold cyan]Processing Time:[/bold cyan] {end_time - start_time:.2f} seconds")
+    
+    # Track Memory Usage
+    mem_usage_mb = df.memory_usage(deep=True).sum() / (1024 * 1024)
+    console.print(f"[bold cyan]Final Memory Usage:[/bold cyan] {mem_usage_mb:.2f} MB")
+
+    console.print("\n[bold green]Thank you for using this tool![/bold green]")
+    return df
+
+if __name__ == '__main__':
+    cli()

data_autoeda-0.1.1/autoeda/insights.py

@@ -0,0 +1,52 @@
+import pandas as pd
+from typing import List
+
+def generate_insights(df: pd.DataFrame) -> List[str]:
+    insights = []
+    
+    # Missing values
+    total_cells = df.shape[0] * df.shape[1]
+    missing_cells = df.isnull().sum().sum()
+    missing_pct = (missing_cells / total_cells) * 100
+    if missing_pct > 0:
+        insights.append(f"Dataset contains {missing_pct:.2f}% missing values overall.")
+    else:
+        insights.append("Dataset is complete with 0% missing values.")
+        
+    for col in df.columns:
+        col_missing = df[col].isnull().mean() * 100
+        if col_missing > 20:
+            insights.append(f"Column '{col}' has significant missing data ({col_missing:.2f}%).")
+            
+    # Duplicates
+    dup_pct = (df.duplicated().sum() / df.shape[0]) * 100
+    if dup_pct > 0:
+        insights.append(f"Dataset contains {dup_pct:.2f}% duplicate rows.")
+        
+    # Correlations (numerical)
+    num_df = df.select_dtypes(include=['number'])
+    if len(num_df.columns) > 1:
+        corr = num_df.corr()
+        for i in range(len(corr.columns)):
+            for j in range(i+1, len(corr.columns)):
+                c_val = corr.iloc[i, j]
+                if pd.notna(c_val):
+                    if c_val > 0.8:
+                        insights.append(f"Strong positive correlation ({c_val:.2f}) exists between '{corr.columns[i]}' and '{corr.columns[j]}'.")
+                    elif c_val < -0.8:
+                        insights.append(f"Strong negative correlation ({c_val:.2f}) exists between '{corr.columns[i]}' and '{corr.columns[j]}'.")
+
+    # Categorical dominance
+    cat_df = df.select_dtypes(include=['object', 'category'])
+    for col in cat_df.columns:
+        val_counts = df[col].value_counts(normalize=True)
+        if not val_counts.empty and val_counts.iloc[0] > 0.8:
+            insights.append(f"Category '{val_counts.index[0]}' dominates the '{col}' column ({val_counts.iloc[0]*100:.2f}%).")
+
+    # ML suitability
+    if missing_pct < 5 and len(num_df.columns) >= 2 and len(df) > 100:
+        insights.append("Dataset appears suitable for Machine Learning with standard preprocessing.")
+    else:
+        insights.append("Recommended preprocessing steps: Extensive data cleaning and imputation required before Machine Learning.")
+        
+    return insights

data_autoeda-0.1.1/autoeda/utils.py

@@ -0,0 +1,17 @@
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+def print_header(title: str):
+    console.print()
+    console.print(Panel(title.upper(), style="bold cyan", expand=False))
+
+def print_section(title: str):
+    console.print(f"\n[bold yellow]--- {title} ---[/bold yellow]")
+
+def print_info(msg: str):
+    console.print(f"[green]✔[/green] {msg}")
+
+def print_warning(msg: str):
+    console.print(f"[bold red]![/bold red] {msg}")

data_autoeda-0.1.1/autoeda/validator.py

@@ -0,0 +1,33 @@
+import os
+import pandas as pd
+from typing import Tuple
+from .utils import print_warning
+
+def load_and_validate(file_path: str) -> Tuple[pd.DataFrame, bool]:
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+    
+    if not file_path.lower().endswith(".csv"):
+        print_warning("File does not end with .csv, attempting to read as CSV anyway.")
+        
+    file_size_mb = os.path.getsize(file_path) / (1024 * 1024)
+    smart_mode = False
+    
+    if file_size_mb > 100:
+        smart_mode = True
+        
+    try:
+        df = pd.read_csv(file_path, low_memory=False)
+    except Exception as e:
+        raise ValueError(f"Failed to read CSV file. Error: {e}")
+        
+    if df.empty:
+        raise ValueError("The dataset is empty.")
+        
+    if len(df.columns) == 0:
+        raise ValueError("No columns found in the dataset.")
+        
+    if len(df) > 100000:
+        smart_mode = True
+        
+    return df, smart_mode

data_autoeda-0.1.1/autoeda/visualizer.py

@@ -0,0 +1,125 @@
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
+import numpy as np
+from rich.prompt import Confirm
+from .utils import console, print_section
+
+def generate_visualizations(df: pd.DataFrame, smart_mode: bool = False):
+    sns.set_theme(style="whitegrid")
+    
+    if smart_mode and len(df) > 50000:
+        console.print(f"[yellow]Smart Mode: Sampling dataset from {len(df):,} to 50,000 rows for faster visualizations.[/yellow]")
+        df = df.sample(50000, random_state=42)
+        
+    print_section("Interactive Visualization Menu")
+    console.print("Select which graphs you want to generate:")
+    
+    show_missing = Confirm.ask("Show Missing Value Graphs?")
+    show_categorical = Confirm.ask("Show Categorical Feature Graphs?")
+    show_numerical = Confirm.ask("Show Numerical Feature Distributions?")
+    show_correlation = Confirm.ask("Show Correlation Heatmap?")
+    show_datetime = Confirm.ask("Show Datetime Charts?")
+    
+    plots = []
+    
+    if show_missing and df.isnull().sum().sum() > 0:
+        plots.append({'type': 'missing_heatmap'})
+        missing_counts = df.isnull().sum()
+        if not missing_counts[missing_counts > 0].empty:
+            plots.append({'type': 'missing_bar'})
+            
+    if show_categorical:
+        cat_cols = df.select_dtypes(include=['object', 'category']).columns
+        for col in cat_cols:
+            vc = df[col].value_counts().head(10)
+            if not vc.empty:
+                plots.append({'type': 'cat_count', 'col': col, 'vc': vc})
+                if len(vc) <= 10:
+                    plots.append({'type': 'cat_pie', 'col': col, 'vc': vc})
+                    
+    if show_numerical:
+        num_cols = df.select_dtypes(include=['number']).columns
+        for col in num_cols:
+            plots.append({'type': 'num_hist', 'col': col})
+            plots.append({'type': 'num_kde', 'col': col})
+            plots.append({'type': 'num_box', 'col': col})
+            
+    if show_correlation:
+        num_df = df.select_dtypes(include=['number'])
+        if len(num_df.columns) > 1:
+            plots.append({'type': 'correlation'})
+            
+    if show_datetime:
+        dt_cols = df.select_dtypes(include=['datetime']).columns
+        for col in dt_cols:
+            plots.append({'type': 'datetime', 'col': col})
+            
+    n_plots = len(plots)
+    if n_plots == 0:
+        console.print("No plots selected or no data available to plot.")
+        return
+        
+    cols = 3
+    rows = (n_plots + cols - 1) // cols
+    
+    fig, axes = plt.subplots(rows, cols, figsize=(18, 5 * rows))
+    
+    # Ensure axes is always a 1D array even if there's only 1 plot
+    if n_plots == 1:
+        axes = np.array([axes])
+    else:
+        axes = axes.flatten()
+    
+    for i, plot_info in enumerate(plots):
+        ax = axes[i]
+        ptype = plot_info['type']
+        
+        if ptype == 'missing_heatmap':
+            sns.heatmap(df.isnull(), cbar=False, cmap='viridis', yticklabels=False, ax=ax)
+            ax.set_title('Missing Value Heatmap')
+        elif ptype == 'missing_bar':
+            missing_counts = df.isnull().sum()
+            missing_counts = missing_counts[missing_counts > 0]
+            missing_counts.plot(kind='bar', color='salmon', ax=ax)
+            ax.set_title('Missing Values per Column')
+            ax.tick_params(axis='x', rotation=45)
+        elif ptype == 'cat_count':
+            col = plot_info['col']
+            sns.countplot(y=col, data=df, order=plot_info['vc'].index, palette='Set2', ax=ax)
+            ax.set_title(f'Count Plot: {col}')
+        elif ptype == 'cat_pie':
+            col = plot_info['col']
+            vc = plot_info['vc']
+            ax.pie(vc.values, labels=vc.index, autopct='%1.1f%%', startangle=90, colors=sns.color_palette('Set2'))
+            ax.set_title(f'Pie Chart: {col}')
+        elif ptype == 'num_hist':
+            col = plot_info['col']
+            sns.histplot(df[col].dropna(), kde=False, ax=ax, color='skyblue')
+            ax.set_title(f'Histogram: {col}')
+        elif ptype == 'num_kde':
+            col = plot_info['col']
+            sns.kdeplot(df[col].dropna(), ax=ax, color='orange', fill=True)
+            ax.set_title(f'KDE Plot: {col}')
+        elif ptype == 'num_box':
+            col = plot_info['col']
+            sns.boxplot(x=df[col].dropna(), ax=ax, color='lightgreen')
+            ax.set_title(f'Boxplot: {col}')
+        elif ptype == 'correlation':
+            corr = df.select_dtypes(include=['number']).corr()
+            sns.heatmap(corr, annot=True, cmap='coolwarm', fmt='.2f', square=True, ax=ax)
+            ax.set_title('Correlation Heatmap')
+        elif ptype == 'datetime':
+            col = plot_info['col']
+            vc = df[col].dropna().dt.date.value_counts().sort_index()
+            vc.plot(kind='line', color='purple', ax=ax)
+            ax.set_title(f'Time Series: {col}')
+            ax.tick_params(axis='x', rotation=45)
+            
+    # Hide any unused subplots
+    for j in range(n_plots, len(axes)):
+        fig.delaxes(axes[j])
+        
+    plt.tight_layout()
+    console.print("[green]Opening all selected plots in a single window. Close the window to continue...[/green]")
+    plt.show(block=True)

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

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: data-autoeda
+Version: 0.1.1
+Summary: Automatic Exploratory Data Analysis, Cleaning, Validation, Visualization, and Smart Insights on ANY CSV dataset.
+Author: shubham kumar
+License: MIT
+Project-URL: Homepage, https://github.com/Shu40/AutoEDA/
+Project-URL: Repository, https://github.com/Shu40/AutoEDA/
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: click>=8.0.0
+Requires-Dist: rich>=10.0.0
+
+# AutoEDA
+
+A production-ready Python package that performs automatic Exploratory Data Analysis (EDA), Data Cleaning, Data Validation, Visualization, and Smart Insights on ANY CSV dataset.
+
+## Features
+- **Dynamic Analysis**: Automatically detects numerical, categorical, boolean, and datetime columns.
+- **Smart Cleaning**: Handles missing values, removes duplicates, and optimizes datatypes automatically.
+- **Visualizations**: Automatically generates relevant charts using Matplotlib and Seaborn.
+- **Smart Insights**: Generates English observations based on statistical findings.
+- **Rich Terminal UI**: Beautiful, organized CLI reports.
+
+## Installation
+
+```bash
+pip install .
+```
+
+## Usage
+
+### Python API
+
+```python
+from autoeda import analyze
+
+# Complete analysis
+analyze("data.csv")
+
+# Only clean data
+# analyze("data.csv", mode="clean")
+```
+
+### CLI
+
+```bash
+# Complete analysis
+autoeda data.csv
+
+# Specific modes
+autoeda data.csv --clean
+autoeda data.csv --visualize
+autoeda data.csv --all
+```

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

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+autoeda/__init__.py
+autoeda/analyzer.py
+autoeda/cleaner.py
+autoeda/cli.py
+autoeda/insights.py
+autoeda/utils.py
+autoeda/validator.py
+autoeda/visualizer.py
+data_autoeda.egg-info/PKG-INFO
+data_autoeda.egg-info/SOURCES.txt
+data_autoeda.egg-info/dependency_links.txt
+data_autoeda.egg-info/entry_points.txt
+data_autoeda.egg-info/requires.txt
+data_autoeda.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

data_autoeda-0.1.1/data_autoeda.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+autoeda = autoeda.cli:cli

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

@@ -0,0 +1,7 @@
+pandas>=1.3.0
+numpy>=1.20.0
+matplotlib>=3.4.0
+seaborn>=0.11.0
+scipy>=1.7.0
+click>=8.0.0
+rich>=10.0.0

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

@@ -0,0 +1 @@
+autoeda

data_autoeda-0.1.1/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "data-autoeda"
+version = "0.1.1"
+description = "Automatic Exploratory Data Analysis, Cleaning, Validation, Visualization, and Smart Insights on ANY CSV dataset."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+    { name = "shubham kumar" }
+]
+dependencies = [
+    "pandas>=1.3.0",
+    "numpy>=1.20.0",
+    "matplotlib>=3.4.0",
+    "seaborn>=0.11.0",
+    "scipy>=1.7.0",
+    "click>=8.0.0",
+    "rich>=10.0.0"
+]
+
+[project.scripts]
+autoeda = "autoeda.cli:cli"
+[project.urls]
+Homepage = "https://github.com/Shu40/AutoEDA/"
+Repository = "https://github.com/Shu40/AutoEDA/"

data_autoeda-0.1.1/setup.cfg

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