autooutlier 0.1.0__py3-none-any.whl

autooutlier/__init__.py

@@ -0,0 +1,26 @@
+# -*- coding: utf-8 -*-
+"""
+autooutlier - Automatic Outlier Detection and Handling for Python
+=================================================================
+
+A professional Python package for automatic outlier detection,
+handling, and statistical analysis of numerical data.
+
+Usage:
+    >>> import autooutlier
+    >>> from autooutlier import handle_outliers, detect_outliers
+"""
+
+from .handling import handle_outliers
+from .summary import before_cleaning_summary
+from .detection import detect_outliers
+from .detection import detect_outlier_method
+from .version import __version__
+    
+__all__ = [
+    "handle_outliers",
+    "before_cleaning_summary",
+    "detect_outliers",
+    "detect_outlier_method",
+    "__version__",
+]

autooutlier/detection.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""Outlier detection methods."""
+
+import numpy as np
+
+from .statistics import mean, std, q1, q3, iqr, skew_measurment
+from .utils import is_numeric
+
+
+def Iqr_method(data,column):
+    q1_value=q1(data[column])
+    q3_value=q3(data[column])
+    IQR=iqr(data[column])
+    LowerFence=q1_value-1.5*IQR
+    upperFence=q3_value+1.5*IQR
+    outliers=(data[column]>upperFence) | (data[column]<LowerFence)
+    return outliers
+
+def z_score_method(data,column):
+    mean_value=mean(data[column])
+    std_value=std(data[column])
+    if std_value==0:
+        return np.zeros(len(data),dtype=bool)
+    z_score=(data[column]-mean_value)/std_value
+    outliers=abs(z_score)>3
+    return outliers
+
+def modified_z_score(data,column):
+    median_value=data[column].median()
+    absolute_value=abs(data[column]-median_value)
+    MAD=absolute_value.median()
+    if MAD==0:
+        return np.zeros(len(data),dtype=bool)
+    modified_z_score=0.6745*(data[column]-median_value)/MAD
+    outliers=abs(modified_z_score)>3.5
+    return outliers
+
+def percentile_method(data,column):
+    lower_limit=np.percentile(data[column],5)
+    upper_limit=np.percentile(data[column],95)
+    outliers=(data[column]>upper_limit) | (data[column]<lower_limit)
+    return outliers
+
+def detect_outlier_method(data,column):
+    numeric=is_numeric(data,column)
+    if not numeric :
+        return "It is not a numerical Column"
+    distribution=skew_measurment(data[column])
+    if distribution in ['Perfectly Symmetric','Approximately Symmetric']:
+        detection_method='z_score'
+    elif distribution in ['Highly Right Skewed','Highly Left Skewed','Moderately Right Skewed','Moderately Left Skewed']:
+        detection_method='modified_z_score'
+    else:
+        detection_method='Iqr_method'
+    return detection_method
+
+def detect_outliers(data,column):
+    method=detect_outlier_method(data,column)
+
+    if method == 'z_score':
+       return z_score_method(data,column)
+
+    elif method == 'modified_z_score':
+      return modified_z_score(data,column)
+
+    else:
+       return Iqr_method(data,column)

autooutlier/handling.py

@@ -0,0 +1,173 @@
+# -*- coding: utf-8 -*-
+"""Outlier handling and replacement methods."""
+
+import numpy as np
+import pandas as pd
+
+from .statistics import mean, median, mode, q1, q3, iqr, skew, skew_measurment
+from .utils import is_numeric, is_time_series, is_continous, outlier_count, outlier_percentage
+from .detection import (
+    Iqr_method,
+    z_score_method,
+    modified_z_score,
+    percentile_method,
+    detect_outlier_method,
+    detect_outliers,
+)
+
+
+def winsorization(data,column):
+    data[column]=data[column].astype(float)
+    q1_value=q1(data[column])
+    q3_value=q3(data[column])
+    IQR=iqr(data[column])
+    LowerFence=q1_value-1.5*IQR
+    upperFence=q3_value+1.5*IQR
+    data.loc[data[column]>upperFence,column]=upperFence
+    data.loc[data[column]<LowerFence,column]=LowerFence
+    return data
+
+def interpolate(data,column,outliers):
+    data.loc[outliers,column]=np.nan
+    data[column]=data[column].interpolate()
+    return data
+
+def replace_with_median(data,column,outliers):
+    data[column]=data[column].astype(float)
+    median_value=median(data[column])
+    data.loc[outliers,column]=median_value
+    return data
+
+def replace_with_mean(data,column,outliers):
+     data[column]=data[column].astype(float)
+     mean_value=mean(data[column])
+     data.loc[outliers,column]=mean_value
+     return data
+
+def replace_with_mode(data,column,outliers):
+     data[column]=data[column].astype(float)
+     mode_value=mode(data[column]).iloc[0]
+     data.loc[outliers,column]=mode_value
+     return data
+
+def remove_outliers(data,column,outliers):
+    data=data[~outliers].copy()
+    return data
+
+def replace_with_custom_value(data,column,outliers,value):
+    data.loc[outliers,column]=value
+    return data
+
+def replace_with_backward_fill(data,column,outliers):
+    data.loc[outliers,column]=np.nan
+    data[column]=data[column].bfill().ffill()
+    return data
+
+def replace_with_forward_fill(data,column,outliers):
+    data.loc[outliers,column]=np.nan
+    data[column]=data[column].ffill().bfill()
+    return data
+
+def is_binary(data, column):
+    return data[column].nunique() == 2
+
+def detect_handler(data,column):
+     numeric=is_numeric(data,column)
+     outliers=detect_outliers(data,column)
+     percentage=outlier_percentage(outliers)
+     series=is_time_series(data,column)
+     continous=is_continous(data,column)
+     distribution=skew_measurment(data[column])
+     if not numeric :
+        return "It is not a numerical Column"
+     if series==True:
+       handling_method='interpolate'
+     elif continous==True:
+        handling_method='interpolate'
+     elif percentage<=5:
+        handling_method='winsorization'
+     elif distribution in ['Highly Right Skewed','Highly Left Skewed','Moderately Right Skewed','Moderately Left Skewed']:
+        handling_method='median'
+     elif distribution in ['Perfectly Symmetric','Approximately Symmetric']:
+        handling_method='mean'
+     else:
+         handling_method='median'
+     return handling_method
+
+def handle_outliers(data,column,detection_method='auto',replacement='auto',value=None):
+    numeric_check=is_numeric(data,column)
+    if numeric_check==False:
+        return "It is Not a Numerical Data"
+    if is_binary(data, column):
+       print( "Binary columns are not suitable for outlier detection")
+    if(detection_method=='auto'):
+         detection_method=detect_outlier_method(data,column)
+         if detection_method == 'z_score':
+            outlier = z_score_method(data,column)
+
+         elif detection_method == 'modified_z_score':
+          outlier = modified_z_score(data,column)
+
+         elif detection_method == 'Iqr_method':
+           outlier = Iqr_method(data,column)
+
+         elif detection_method == 'percentile':
+              outlier = percentile_method(data,column)
+
+         else:
+             print( "Invalid Detection Method")
+    elif detection_method=='Iqr_method':
+        outlier= Iqr_method(data,column)
+    elif detection_method=='z_score':
+        outlier= z_score_method(data,column)
+    elif detection_method=='modified_z_score':
+         outlier=modified_z_score(data,column)
+    elif detection_method=='percentile':
+        outlier=percentile_method(data,column)
+    else:
+       print( "Invalid Detection Method")
+    if (replacement=='auto'):
+      replacement=detect_handler(data,column)
+      if replacement=='interpolate':
+        data= interpolate(data,column,outlier)
+      elif replacement=='winsorization':
+        data= winsorization(data,column)
+      elif replacement=='median':
+        data= replace_with_median(data,column,outlier)
+      elif replacement=='mode':
+        data=replace_with_mode(data,column,outlier)
+      elif replacement=='mean':
+          data= replace_with_mean(data,column,outlier)
+    if replacement=='interpolate':
+        data= interpolate(data,column,outlier)
+    elif replacement=='winsorization':
+        data= winsorization(data,column)
+    elif replacement=='median':
+        data= replace_with_median(data,column,outlier)
+    elif replacement=='mode':
+        data= replace_with_mode(data,column,outlier)
+    elif replacement=='mean':
+          data= replace_with_mean(data,column,outlier)
+    elif replacement=='custom':
+         if value is None:
+             print( "Please Provide Custom Value")
+         data=replace_with_custom_value(data,column,outlier,value)
+    elif replacement=='remove':
+        data=remove_outliers(data,column,outlier)
+    elif replacement=='bfill':
+        data= replace_with_backward_fill(data,column,outlier)
+    elif replacement=='ffill':
+        data= replace_with_forward_fill(data,column,outlier)
+    else:
+        print("Invalid Replacement Method")
+    outlier = detect_outliers(data, column)
+    after_cleaning_report = {
+        "Column": [column],
+        "Detection Method": [detection_method],
+        "Handling Method": [replacement],
+        "Outlier Count": [outlier_count(outlier)],
+        "Outlier Percentage": [outlier_percentage(outlier)],
+        "Skewness": [skew(data[column])],
+        "Distribution": [skew_measurment(data[column])]
+    }
+    return data,pd.DataFrame(after_cleaning_report)

autooutlier/statistics.py

@@ -0,0 +1,71 @@
+# -*- coding: utf-8 -*-
+"""Statistical functions for outlier detection."""
+
+import numpy as np
+from scipy.stats import skew as scipy_skew
+
+
+def mean(data):
+    return data.mean()
+
+def median(data):
+    return data.median()
+
+def mode(data):
+    return data.mode()
+
+def std(data):
+    return data.std()
+
+def var(data):
+    return data.var()
+
+def data_range(data):
+    return data.max()-data.min()
+
+def q1(data):
+    a= np.percentile(data,25)
+    return a
+
+def q3(data):
+     b= np.percentile(data,75)
+     return b
+
+def iqr(data):
+     return q3(data)-q1(data)
+
+def skew(data):
+    return scipy_skew(data,bias=False)
+
+def skew_measurment(data):
+    s=skew(data)
+    if s==0:
+        return "Perfectly Symmetric"
+    if  s >= -0.5and s <= 0.5:
+        return "Approximately Symmetric"
+    if s >= 0.5 and s<= 1:
+        return "Moderately Right Skewed"
+    if s>1:
+        return "Highly Right Skewed"
+    if s<-1:
+        return "Highly Left Skewed"
+    if s>=-1 and s<=-0.5:
+        return "Moderately Left Skewed"
+
+def is_normal(data):
+    s=skew(data)
+    if (abs(s)<0.5):
+        return True
+    return False
+
+def kurtosis(data):
+    return data.kurt()
+
+def kurtosis_measurement(data):
+    k=kurtosis(data)
+    if k==0:
+        return "Normal Distribution"
+    if k>0:
+        return "Heavier Tail"
+    if k<0:
+        return "Lighter Tail"

autooutlier/summary.py

@@ -0,0 +1,25 @@
+# -*- coding: utf-8 -*-
+"""Summary report generation for outlier analysis."""
+
+import pandas as pd
+
+from .statistics import skew, skew_measurment
+from .utils import outlier_count, outlier_percentage
+from .detection import detect_outliers, detect_outlier_method
+from .handling import detect_handler
+
+
+def before_cleaning_summary(data, column):
+    outliers = detect_outliers(data, column)
+
+    report = {
+        "Column": [column],
+        "Suggested_Detection Method": [detect_outlier_method(data,column)],
+        "Handling Method": [detect_handler(data,column)],
+        "Skewness": [skew(data[column])],
+        "Distribution": [skew_measurment(data[column])],
+        "Outlier Count": [outlier_count(outliers)],
+        "Outlier Percentage": [outlier_percentage(outliers)]
+    }
+
+    return pd.DataFrame(report)

autooutlier/utils.py

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+"""Utility functions for outlier detection."""
+
+import pandas as pd
+
+
+def is_numeric(data,column):
+    return pd.api.types.is_numeric_dtype(data[column])
+
+def is_time_series(data,column):
+    return pd.api.types.is_datetime64_any_dtype(data[column])
+
+def is_continous(data,column):
+    numeric=is_numeric(data,column)
+    return ( numeric==True and (data[column].is_monotonic_increasing or data[column].is_monotonic_decreasing))
+
+def outlier_count(outliers):
+    return outliers.sum()
+
+def outlier_percentage(outliers):
+    return (outliers.sum()/len(outliers))*100

autooutlier/version.py

@@ -0,0 +1,4 @@
+# -*- coding: utf-8 -*-
+"""Version information for autooutlier."""
+
+__version__ = "0.1.0"

autooutlier-0.1.0.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: autooutlier
+Version: 0.1.0
+Summary: Automatic outlier detection and handling for Python.
+Author: Suruthika C D
+License: MIT
+Project-URL: Homepage, https://github.com/suruthika-cd/autooutlier
+Project-URL: Repository, https://github.com/suruthika-cd/autooutlier
+Project-URL: Documentation, https://github.com/suruthika-cd/autooutlier/tree/main/docs
+Project-URL: Issues, https://github.com/suruthika-cd/autooutlier/issues
+Project-URL: Changelog, https://github.com/suruthika-cd/autooutlier/blob/main/CHANGELOG.md
+Keywords: outlier,outlier-detection,statistics,data-cleaning,data-science,machine-learning,preprocessing,pandas
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Dynamic: license-file
+
+# autooutlier
+
+**Automatic Outlier Detection and Handling for Python**
+
+[![Python 3.8+](https://img.shields.io/badge/python-3.8+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![PyPI version](https://img.shields.io/pypi/v/autooutlier.svg)](https://pypi.org/project/autooutlier/)
+
+---
+
+## Overview
+
+`autooutlier` is a Python package that **automatically detects, analyzes, and handles outliers** in numerical data. It intelligently selects the best detection and handling methods based on data distribution — requiring **zero configuration** from the user.
+
+Simply pass your DataFrame and column name, and `autooutlier` handles the rest.
+
+---
+
+## Features
+
+- **Automatic Detection** — Selects the optimal outlier detection method (Z-Score, Modified Z-Score, IQR, Percentile) based on data skewness.
+- **Automatic Handling** — Chooses the best outlier replacement strategy (winsorization, mean/median/mode replacement, interpolation, etc.) based on data characteristics.
+- **Statistical Analysis** — Provides mean, median, mode, standard deviation, variance, skewness, kurtosis, and distribution classification.
+- **Pre-Cleaning Summary** — Generates a comprehensive report before cleaning, including detection method, handling strategy, outlier count, and percentage.
+- **Post-Cleaning Report** — Returns both the cleaned dataset and an after-cleaning summary report.
+- **Flexible Manual Control** — Override automatic selections with manual detection and handling methods when needed.
+- **Visualization** — Built-in box plot support via Seaborn.
+
+---
+
+## Installation
+
+```bash
+pip install autooutlier
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/suruthika-cd/autooutlier.git
+cd autooutlier
+pip install -e .
+```
+
+### Dependencies
+
+- Python >= 3.8
+- NumPy >= 1.21.0
+- Pandas >= 1.3.0
+- SciPy >= 1.7.0
+- Seaborn >= 0.11.0
+- Matplotlib >= 3.4.0
+
+---
+
+## Quick Start
+
+```python
+import pandas as pd
+from autooutlier import handle_outliers, before_cleaning_summary, detect_outliers
+
+# Load your data
+df = pd.DataFrame({"values": [10, 12, 14, 11, 13, 100, 15, 12, 14, 11]})
+
+# Get a pre-cleaning summary report
+summary = before_cleaning_summary(df, "values")
+print(summary)
+
+# Automatically detect and handle outliers
+cleaned_data, report = handle_outliers(df, "values")
+print(report)
+print(cleaned_data)
+```
+
+---
+
+## Usage Examples
+
+### Automatic Outlier Detection
+
+```python
+from autooutlier import detect_outliers
+
+outlier_mask = detect_outliers(df, "column_name")
+print(f"Outliers found: {outlier_mask.sum()}")
+```
+
+### Automatic Outlier Handling
+
+```python
+from autooutlier import handle_outliers
+
+# Fully automatic — detection and handling methods are chosen for you
+cleaned_df, report = handle_outliers(df, "column_name")
+```
+
+### Manual Detection Method
+
+```python
+# Use a specific detection method
+cleaned_df, report = handle_outliers(df, "column_name", detection_method="z_score")
+```
+
+Available detection methods: `'auto'`, `'Iqr_method'`, `'z_score'`, `'modified_z_score'`, `'percentile'`
+
+### Manual Handling Method
+
+```python
+# Use a specific replacement strategy
+cleaned_df, report = handle_outliers(df, "column_name", replacement="median")
+```
+
+Available replacement methods: `'auto'`, `'interpolate'`, `'winsorization'`, `'median'`, `'mean'`, `'mode'`, `'custom'`, `'remove'`, `'bfill'`, `'ffill'`
+
+### Custom Value Replacement
+
+```python
+cleaned_df, report = handle_outliers(df, "column_name", replacement="custom", value=0)
+```
+
+### Pre-Cleaning Summary
+
+```python
+from autooutlier import before_cleaning_summary
+
+summary = before_cleaning_summary(df, "column_name")
+print(summary)
+```
+
+Output includes: suggested detection method, handling method, skewness, distribution type, outlier count, and outlier percentage.
+
+---
+
+## API Overview
+
+### Public API
+
+| Function | Description |
+|---|---|
+| `handle_outliers(data, column, detection_method='auto', replacement='auto', value=None)` | Detect and handle outliers. Returns `(cleaned_data, report)`. |
+| `detect_outliers(data, column)` | Detect outliers automatically. Returns a boolean mask. |
+| `detect_outlier_method(data, column)` | Returns the suggested detection method name. |
+| `before_cleaning_summary(data, column)` | Returns a DataFrame summary report before cleaning. |
+
+### Module Reference
+
+| Module | Contents |
+|---|---|
+| `autooutlier.statistics` | `mean`, `median`, `mode`, `std`, `var`, `data_range`, `q1`, `q3`, `iqr`, `skew`, `skew_measurment`, `is_normal`, `kurtosis`, `kurtosis_measurement` |
+| `autooutlier.detection` | `Iqr_method`, `z_score_method`, `modified_z_score`, `percentile_method`, `detect_outlier_method`, `detect_outliers` |
+| `autooutlier.handling` | `winsorization`, `interpolate`, `replace_with_mean`, `replace_with_median`, `replace_with_mode`, `replace_with_custom_value`, `replace_with_forward_fill`, `replace_with_backward_fill`, `remove_outliers`, `detect_handler`, `handle_outliers` |
+| `autooutlier.summary` | `before_cleaning_summary` |
+| `autooutlier.visualization` | `box_plot` |
+| `autooutlier.utils` | `is_numeric`, `is_time_series`, `is_continous`, `outlier_count`, `outlier_percentage` |
+
+---
+
+## License
+
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
+
+---
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for all notable changes.

autooutlier-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+autooutlier/__init__.py,sha256=FdNiubZ9h9M_LWc4cSl7wYdvY5DLNV02DOpNSpta5CY,727
+autooutlier/detection.py,sha256=I67FOHk9R6V-AVl4wPkMWLSIV0C2qWFKM21pIR-LRIE,2085
+autooutlier/handling.py,sha256=SwWanqUyMoXZ7hCVKnPuJgRAUMDm3od2sCu3ota4BVI,6103
+autooutlier/statistics.py,sha256=KKZAyzGQie2nk-MeiwhBFv-zojZlV3LFDreU7ntUfc0,1343
+autooutlier/summary.py,sha256=-LR27vQ-CZc9XIAvZXZho2w_M-fULCUByLw9lHO8t_A,817
+autooutlier/utils.py,sha256=Yu-C-sP5_k9sDh7RAUFWD9k6zeGb2vW5khv600wcMNE,590
+autooutlier/version.py,sha256=mo7LZfe2rfqFJJKr1EEhMo40k827XqkGRbCbYwqJupE,90
+autooutlier-0.1.0.dist-info/licenses/LICENSE,sha256=uwwHmyknRbaARKLV6ZVhLLdag_GxRTPqzSZmdX5awjI,1069
+autooutlier-0.1.0.dist-info/METADATA,sha256=WycEeWSmkLmgNkL-2qrk4aB3fd9-zx1pHTVNTR-azP4,7273
+autooutlier-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+autooutlier-0.1.0.dist-info/top_level.txt,sha256=Pk6Zbp6lqeso22EOztDWKbdR15JfI7aDnT_pIv3OxlM,12
+autooutlier-0.1.0.dist-info/RECORD,,

autooutlier-0.1.0.dist-info/WHEEL

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

autooutlier-0.1.0.dist-info/licenses/LICENSE

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

autooutlier-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+autooutlier