sagaranalysis 0.1.0__tar.gz

sagaranalysis-0.1.0/LICENSE

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

sagaranalysis-0.1.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.4
+Name: sagaranalysis
+Version: 0.1.0
+Summary: A production-ready Python library for one-line data cleaning, EDA, and beautiful HTML reporting.
+Author-email: Sagar <sagarmohite4895@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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: jinja2>=3.0.0
+Requires-Dist: scipy>=1.7.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Dynamic: license-file
+
+# SagarAnalysis
+
+A production-ready, beginner-friendly Python package designed for one-line data cleaning, one-line Exploratory Data Analysis (EDA), and stunning, glassmorphic HTML reporting.
+
+## Features
+
+- **One-line Cleaning (`clean(df)`)**:
+  - Automatically standardizes column names to `snake_case`.
+  - Removes duplicate rows.
+  - Detects and drops constant/highly missing columns.
+  - Imputes missing values intelligently (median/mean/mode/unknown).
+  - Handles numerical outliers via clipping.
+  - Coerces data types (string to numeric, string to datetime, Yes/No to boolean).
+- **One-line EDA & Report (`analysis(df)`)**:
+  - Generates a comprehensive overview of the dataset.
+  - Performs descriptive statistics and missingness analysis.
+  - Discovers high correlations and skewness.
+  - Auto-detects the target column and runs target profiling.
+- **Stunning HTML Reports (`report.save()`)**:
+  - Interactive, modern Glassmorphism design.
+  - Supports light/dark theme toggles.
+  - Fully responsive layout with embedded Base64 charts.
+  - Searchable variables, collapsible details, and clear data insights.
+
+## Installation
+
+```bash
+pip install sagaranalysis
+```
+
+## Quick Start
+
+```python
+import pandas as pd
+import sagaranalysis as sa
+
+# Load your dirty dataset
+df = pd.read_csv("dirty_data.csv")
+
+# Clean your data in one line
+cleaned_df = sa.clean(df)
+
+# Perform automatic EDA and generate insights
+report = sa.analysis(cleaned_df)
+
+# View or save the report
+report.show()                  # Opens in local browser or renders in Jupyter Notebook
+report.save("report.html")     # Saves self-contained report to disk
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

sagaranalysis-0.1.0/README.md

@@ -0,0 +1,53 @@
+# SagarAnalysis
+
+A production-ready, beginner-friendly Python package designed for one-line data cleaning, one-line Exploratory Data Analysis (EDA), and stunning, glassmorphic HTML reporting.
+
+## Features
+
+- **One-line Cleaning (`clean(df)`)**:
+  - Automatically standardizes column names to `snake_case`.
+  - Removes duplicate rows.
+  - Detects and drops constant/highly missing columns.
+  - Imputes missing values intelligently (median/mean/mode/unknown).
+  - Handles numerical outliers via clipping.
+  - Coerces data types (string to numeric, string to datetime, Yes/No to boolean).
+- **One-line EDA & Report (`analysis(df)`)**:
+  - Generates a comprehensive overview of the dataset.
+  - Performs descriptive statistics and missingness analysis.
+  - Discovers high correlations and skewness.
+  - Auto-detects the target column and runs target profiling.
+- **Stunning HTML Reports (`report.save()`)**:
+  - Interactive, modern Glassmorphism design.
+  - Supports light/dark theme toggles.
+  - Fully responsive layout with embedded Base64 charts.
+  - Searchable variables, collapsible details, and clear data insights.
+
+## Installation
+
+```bash
+pip install sagaranalysis
+```
+
+## Quick Start
+
+```python
+import pandas as pd
+import sagaranalysis as sa
+
+# Load your dirty dataset
+df = pd.read_csv("dirty_data.csv")
+
+# Clean your data in one line
+cleaned_df = sa.clean(df)
+
+# Perform automatic EDA and generate insights
+report = sa.analysis(cleaned_df)
+
+# View or save the report
+report.show()                  # Opens in local browser or renders in Jupyter Notebook
+report.save("report.html")     # Saves self-contained report to disk
+```
+
+## License
+
+This project is licensed under the MIT License - see the LICENSE file for details.

sagaranalysis-0.1.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sagaranalysis"
+version = "0.1.0"
+authors = [
+    { name = "Sagar", email = "sagarmohite4895@gmail.com" }
+]
+description = "A production-ready Python library for one-line data cleaning, EDA, and beautiful HTML reporting."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+dependencies = [
+    "pandas>=1.3.0",
+    "numpy>=1.20.0",
+    "matplotlib>=3.4.0",
+    "seaborn>=0.11.0",
+    "jinja2>=3.0.0",
+    "scipy>=1.7.0"
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "black",
+    "ruff"
+]

sagaranalysis-0.1.0/sagaranalysis/__init__.py

@@ -0,0 +1,125 @@
+import logging
+from typing import Optional, Dict
+import pandas as pd
+
+# Setup package logging
+logging.getLogger("sagaranalysis").addHandler(logging.NullHandler())
+
+from sagaranalysis.cleaning import (
+    CleaningPipeline,
+    ColumnStandardizer,
+    DuplicateRemover,
+    ColumnDropper,
+    TypeCoercer,
+    MissingImputer,
+    OutlierHandler,
+    CleaningSummary
+)
+from sagaranalysis.eda import DatasetAnalyzer
+from sagaranalysis.report import Report
+from sagaranalysis.visualization import (
+    plot_missing_values,
+    plot_numerical_distribution,
+    plot_categorical_frequency,
+    plot_correlation_heatmap,
+    plot_target_relationship
+)
+
+def clean(
+    df: pd.DataFrame,
+    missing_threshold: float = 0.60,
+    constant_threshold: float = 0.99,
+    outlier_multiplier: float = 1.5
+) -> pd.DataFrame:
+    """
+    Cleans a pandas DataFrame in one line.
+    
+    Standardizes column names, removes duplicates, drops constant or highly missing 
+    columns, coerces types (dates, numbers-as-strings, booleans), imputes missing values 
+    intelligently, and clips outliers.
+    
+    Args:
+        df: The pandas DataFrame to clean.
+        missing_threshold: Percentage of null values above which a column is dropped (default 60%).
+        constant_threshold: Percentage of duplicate values above which a column is dropped (default 99%).
+        outlier_multiplier: IQR multiplier for clipping outliers (default 1.5).
+        
+    Returns:
+        A cleaned copy of the DataFrame with `attrs['cleaning_summary']` set to a `CleaningSummary` object.
+    """
+    pipeline = CleaningPipeline()
+    pipeline.add_step(ColumnStandardizer())
+    pipeline.add_step(DuplicateRemover())
+    pipeline.add_step(ColumnDropper(missing_threshold, constant_threshold))
+    pipeline.add_step(TypeCoercer())
+    pipeline.add_step(MissingImputer())
+    pipeline.add_step(OutlierHandler(outlier_multiplier))
+    
+    cleaned_df, summary = pipeline.run(df)
+    return cleaned_df
+
+
+def analysis(df: pd.DataFrame, target: Optional[str] = None) -> Report:
+    """
+    Analyzes a pandas DataFrame in one line and returns an interactive Report object.
+    
+    Extracts descriptive statistics, profiles each column, generates base64-encoded 
+    visualizations, and runs automated insight checks.
+    
+    Args:
+        df: The pandas DataFrame to analyze.
+        target: Optional target column name. If not specified, attempts to auto-detect.
+        
+    Returns:
+        A Report object ready to show, save, summarize, or expose insights.
+    """
+    from halo import Halo
+    spinner = Halo(text="Analyzing dataset features...", spinner="dots", color="magenta")
+    spinner.start()
+    
+    try:
+        # 1. Perform calculations
+        analyzer = DatasetAnalyzer(df, target=target)
+        results = analyzer.analyze()
+        
+        detected_target = results["overview"]["target_detected"]
+        detected_target_type = results["target"]["type"] if results["target"] else None
+
+        # 2. Generate Base64 Visualizations
+        plots: Dict[str, str] = {}
+        
+        # Missing values plot (returns None if no missing values)
+        missing_plot = plot_missing_values(df)
+        if missing_plot:
+            plots["missingness"] = missing_plot
+
+        # Column distributions
+        for col_name, col_meta in results["columns"].items():
+            series = df[col_name]
+            if col_meta["type"] == "numeric":
+                plots[col_name] = plot_numerical_distribution(series, col_name)
+            elif col_meta["type"] == "categorical":
+                plots[col_name] = plot_categorical_frequency(series, col_name)
+
+        # Correlation heatmap
+        corr_heatmap = plot_correlation_heatmap(df)
+        if corr_heatmap:
+            plots["correlation"] = corr_heatmap
+
+        # Target relationships
+        if detected_target and results["target"]:
+            relationships = results["target"].get("relationships", {})
+            for feat in relationships.keys():
+                plots[f"target_{feat}"] = plot_target_relationship(
+                    df, feat, detected_target, detected_target_type
+                )
+
+        # 3. Retrieve any cleaning summary attached to the DataFrame
+        cleaning_summary = df.attrs.get("cleaning_summary")
+        
+        spinner.succeed("Statistical profiling and visual analytics complete!")
+        # 4. Construct Report
+        return Report(results, plots, cleaning_summary=cleaning_summary)
+    except Exception as e:
+        spinner.fail(f"Analysis failed: {str(e)}")
+        raise e

sagaranalysis-0.1.0/sagaranalysis/cleaning/__init__.py

@@ -0,0 +1,22 @@
+from sagaranalysis.cleaning.base import CleaningStep
+from sagaranalysis.cleaning.pipeline import CleaningPipeline, CleaningSummary
+from sagaranalysis.cleaning.rules import (
+    ColumnStandardizer,
+    DuplicateRemover,
+    ColumnDropper,
+    TypeCoercer,
+    MissingImputer,
+    OutlierHandler
+)
+
+__all__ = [
+    "CleaningStep",
+    "CleaningPipeline",
+    "CleaningSummary",
+    "ColumnStandardizer",
+    "DuplicateRemover",
+    "ColumnDropper",
+    "TypeCoercer",
+    "MissingImputer",
+    "OutlierHandler"
+]

sagaranalysis-0.1.0/sagaranalysis/cleaning/base.py

@@ -0,0 +1,23 @@
+from abc import ABC, abstractmethod
+from typing import Tuple, List
+import pandas as pd
+
+class CleaningStep(ABC):
+    """
+    Abstract base class for a single data cleaning step.
+    Each step must implement `execute` and return a cleaned copy/view
+    of the DataFrame along with a list of logs describing what was changed.
+    """
+    @abstractmethod
+    def execute(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, List[str]]:
+        """
+        Executes the cleaning operation.
+
+        Args:
+            df: The input pandas DataFrame.
+
+        Returns:
+            A tuple of (cleaned_df, logs_list) where logs_list contains 
+            messages detailing changes.
+        """
+        pass

sagaranalysis-0.1.0/sagaranalysis/cleaning/pipeline.py

@@ -0,0 +1,118 @@
+import time
+import logging
+from typing import List, Tuple
+import pandas as pd
+from sagaranalysis.cleaning.base import CleaningStep
+
+logger = logging.getLogger("sagaranalysis.cleaning")
+
+class CleaningSummary:
+    """
+    Holds metadata and logs about a finished data cleaning session.
+    """
+    def __init__(self, initial_shape: Tuple[int, int]):
+        self.initial_shape = initial_shape
+        self.final_shape = initial_shape
+        self.logs: List[str] = []
+        self.execution_time_seconds: float = 0.0
+
+    @property
+    def rows_removed(self) -> int:
+        return self.initial_shape[0] - self.final_shape[0]
+
+    @property
+    def cols_removed(self) -> int:
+        return self.initial_shape[1] - self.final_shape[1]
+
+    def add_logs(self, step_logs: List[str]) -> None:
+        self.logs.extend(step_logs)
+
+    def report(self) -> str:
+        """
+        Generates a clean markdown string detailing the cleaning summary.
+        """
+        report_lines = [
+            "# Data Cleaning Summary Report",
+            f"- **Execution Time:** {self.execution_time_seconds:.4f} seconds",
+            f"- **Initial Shape:** {self.initial_shape[0]} rows, {self.initial_shape[1]} columns",
+            f"- **Final Shape:** {self.final_shape[0]} rows, {self.final_shape[1]} columns",
+            f"- **Rows Removed:** {self.rows_removed}",
+            f"- **Columns Removed:** {self.cols_removed}",
+            "\n## Operations Applied:"
+        ]
+        
+        if self.logs:
+            for log in self.logs:
+                report_lines.append(f"- {log}")
+        else:
+            report_lines.append("- No operations performed.")
+            
+        return "\n".join(report_lines)
+
+    def __str__(self) -> str:
+        return self.report()
+
+    def __repr__(self) -> str:
+        return f"<CleaningSummary initial={self.initial_shape} final={self.final_shape} logs={len(self.logs)}>"
+
+
+class CleaningPipeline:
+    """
+    Orchestrates the execution of multiple CleaningSteps.
+    """
+    def __init__(self):
+        self.steps: List[CleaningStep] = []
+
+    def add_step(self, step: CleaningStep) -> None:
+        """
+        Appends a cleaning step to the pipeline.
+        """
+        self.steps.append(step)
+
+    def run(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, CleaningSummary]:
+        """
+        Runs all cleaning steps in the pipeline sequentially.
+        """
+        from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
+        from halo import Halo
+        
+        start_time = time.time()
+        summary = CleaningSummary(df.shape)
+        
+        cleaned_df = df.copy()
+        
+        # Display rich progress bar
+        with Progress(
+            SpinnerColumn(spinner_name="dots", style="cyan"),
+            TextColumn("[cyan]{task.description}"),
+            BarColumn(bar_width=30, style="dim cyan", complete_style="cyan"),
+            TextColumn("[cyan]{task.percentage:>3.0f}%"),
+            transient=True
+        ) as progress:
+            task = progress.add_task("Executing cleaning pipeline...", total=len(self.steps))
+            for i, step in enumerate(self.steps):
+                step_name = step.__class__.__name__
+                progress.update(task, description=f"Step {i+1}/{len(self.steps)}: {step_name}")
+                try:
+                    cleaned_df, step_logs = step.execute(cleaned_df)
+                    summary.add_logs(step_logs)
+                except Exception as e:
+                    logger.error(f"Error in cleaning step {step_name}: {e}", exc_info=True)
+                    summary.add_logs([f"ERROR in {step_name}: {str(e)}"])
+                
+                # Introduce a small artificial delay so that progress updates are readable to users
+                time.sleep(0.05)
+                progress.advance(task, 1)
+
+        # Show final success spinner
+        success_spinner = Halo(text="Dataset cleaned successfully!", spinner="dots", color="cyan")
+        success_spinner.start()
+        success_spinner.succeed()
+
+        summary.final_shape = cleaned_df.shape
+        summary.execution_time_seconds = time.time() - start_time
+        
+        # Attach summary to the DataFrame attributes metadata
+        cleaned_df.attrs["cleaning_summary"] = summary
+        
+        return cleaned_df, summary