datra 0.1.0__py3-none-any.whl

datra/__init__.py

@@ -0,0 +1,4 @@
+from .audit import Audit
+from .cleaner import clean
+
+__all__ = ["Audit", "clean"]

datra/audit.py

@@ -0,0 +1,60 @@
+from functools import cached_property
+
+from datra.io import load
+from datra.checks.validate import validate as validate_df
+from datra.checks.completeness import completeness as check_completeness
+from datra.checks.uniqueness import uniqueness as check_uniqueness
+from datra.checks.outliers import outliers as check_outliers
+from datra.checks.profile import profile as check_profile
+from datra.scoring.score import calculate_score
+from datra.reports import build_report, save_report
+
+
+class Audit:
+    def __init__(self, input_data):
+        self.df = load(input_data)
+    
+    @cached_property
+    def completeness(self):
+        return check_completeness(self.df)
+
+    @cached_property
+    def uniqueness(self):
+        return check_uniqueness(self.df)
+
+    @cached_property
+    def outliers(self):
+        return check_outliers(self.df)
+
+    @cached_property
+    def profile(self):
+        return check_profile(self.df)
+
+    @cached_property
+    def score(self):
+        metrics_payload = {
+            "completeness": self.completeness,
+            "uniqueness": self.uniqueness,
+            "outliers": self.outliers,
+        }
+        return calculate_score(metrics_payload)
+
+    @property
+    def results(self):
+        return {
+            "profile": self.profile,
+            "completeness": self.completeness,
+            "uniqueness": self.uniqueness,
+            "outliers": self.outliers,
+            "score": self.score,
+        }
+
+    def validate(self, rules: dict):
+        return validate_df(self.df, rules)
+
+    def build_report(self):
+        return build_report(self.results)
+
+    def save_report(self, path="outputs", format="json"):
+        report = self.build_report()
+        return save_report(report, output=path, format=format)

datra/checks/completeness.py

@@ -0,0 +1,19 @@
+import pandas as pd
+
+
+def completeness(df: pd.DataFrame):
+    total_rows = len(df)
+
+    result = {}
+
+    for col in df.columns:
+        missing = df[col].isna().sum()
+        filled = total_rows - missing
+
+        result[col] = {
+            "missing_values": int(missing),
+            "filled_values": int(filled),
+            "completeness_ratio": float(round(filled / total_rows, 4))
+        }
+
+    return result

datra/checks/outliers.py

@@ -0,0 +1,35 @@
+import pandas as pd
+
+
+def outliers(df: pd.DataFrame):
+    results = {}
+
+    numeric_cols = df.select_dtypes(include="number").columns
+
+    for col in numeric_cols:
+        series = df[col].dropna()
+
+        if series.empty:
+            continue
+
+        q1 = series.quantile(0.25)
+        q3 = series.quantile(0.75)
+
+        iqr = q3 - q1
+
+        lower_bound = q1 - 1.5 * iqr
+        upper_bound = q3 + 1.5 * iqr
+
+        outliers_mask = (series < lower_bound) | (series > upper_bound)
+
+        outlier_values = series[outliers_mask]
+
+        results[col] = {
+            "lower_bound": float(lower_bound),
+            "upper_bound": float(upper_bound),
+            "outlier_count": int(outliers_mask.sum()),
+            "outlier_ratio": float(round(outliers_mask.mean(), 4)),
+            # "sample_outliers": outlier_values.head(5).tolist()
+        }
+
+    return results

datra/checks/profile.py

@@ -0,0 +1,49 @@
+import pandas as pd
+
+
+def profile(df: pd.DataFrame):
+    rows, columns = df.shape
+
+    numeric_columns = len(
+        df.select_dtypes(include="number").columns
+    )
+
+    categorical_columns = len(
+        df.select_dtypes(include=["object", "category"]).columns
+    )
+
+    datetime_columns = len(
+        df.select_dtypes(include=["datetime64"]).columns
+    )
+
+    memory_usage_mb = float(round(
+        df.memory_usage(deep=True).sum() / (1024 * 1024),
+        2
+    ))
+
+    duplicate_rows = int(df.duplicated().sum())
+
+    missing_cells = int(df.isna().sum().sum())
+    
+    # columns = {}
+
+    # for col in df.columns:
+    #     col_data = df[col]
+
+    #     columns[col] = {
+    #         "dtype": str(col_data.dtype),
+    #         "missing_pct": round(col_data.isna().mean() * 100, 2),
+    #         "unique_count": int(col_data.nunique(dropna=True)),
+    #         "sample_values": col_data.dropna().astype(str).head(3).tolist()
+    #     }
+
+    return {
+        "rows": rows,
+        "columns": columns,
+        "numeric_columns": numeric_columns,
+        "categorical_columns": categorical_columns,
+        "datetime_columns": datetime_columns,
+        "memory_usage_mb": memory_usage_mb,
+        "duplicate_rows": duplicate_rows,
+        "missing_cells": missing_cells,
+    }

datra/checks/uniqueness.py

@@ -0,0 +1,18 @@
+import pandas as pd
+
+
+def uniqueness(df: pd.DataFrame):
+    total_rows = len(df)
+
+    dup_mask = df.duplicated()
+    duplicate_rows = dup_mask.sum()
+
+    result = {
+        "total_rows": total_rows,
+        "unique_rows": int(len(df) - duplicate_rows),
+        "duplicate_rows": int(duplicate_rows),
+        "duplicate_ratio": float(round(duplicate_rows / total_rows, 4) if total_rows else 0),
+        # "duplicate_sample": df[dup_mask].head(5).to_dict(orient="records")
+    }
+
+    return result

datra/checks/validate.py

@@ -0,0 +1,151 @@
+import pandas as pd
+
+
+def _record_check(summary, column_result, check_name, passed, **details):
+    column_result["checks"][check_name] = {
+        "passed": passed,
+        **details,
+    }
+
+    summary["rules_checked"] += 1
+
+    if passed:
+        summary["rules_passed"] += 1
+    else:
+        summary["rules_failed"] += 1
+        column_result["passed"] = False
+        
+        
+def _check_minimum(df, column, minimum, summary, column_result):
+    violations = int((df[column] < minimum).sum())
+
+    passed = violations == 0
+
+    _record_check(
+        summary,
+        column_result,
+        "minimum",
+        passed,
+        expected=minimum,
+        violations=violations,
+    )
+        
+
+def _check_maximum(df, column, maximum, summary, column_result):
+    violations = int((df[column] > maximum).sum())
+
+    passed = violations == 0
+
+    _record_check(
+        summary,
+        column_result,
+        "maximum",
+        passed,
+        expected=maximum,
+        violations=violations,
+    )
+
+
+def _check_allowed(df, column, allowed, summary, column_result):
+    violations = int(
+        (~df[column].isin(allowed)).sum()
+    )
+
+    passed = violations == 0
+
+    _record_check(
+        summary,
+        column_result,
+        "allowed",
+        passed,
+        expected=allowed,
+        violations=violations,
+    )
+
+
+def _check_unique(df, column, summary, column_result):
+    violations = int(df[column].duplicated().sum())
+
+    passed = violations == 0
+
+    _record_check(
+        summary,
+        column_result,
+        "unique",
+        passed,
+        violations=violations,
+    )
+
+
+def validate(df: pd.DataFrame, rules: dict):
+    summary = {
+        "columns_checked": 0,
+        "rules_checked": 0,
+        "rules_passed": 0,
+        "rules_failed": 0,
+        "validation_score": 0.0,
+    }
+
+    results = {}
+
+    for column, column_rules in rules.items():
+        if column not in df.columns:
+            continue
+
+        summary["columns_checked"] += 1
+
+        column_result = {
+            "passed": True,
+            "checks": {}
+        }
+        
+        if "min" in column_rules:
+            _check_minimum(
+                df,
+                column,
+                column_rules["min"],
+                summary,
+                column_result,
+            )
+
+        if "max" in column_rules:
+            _check_maximum(
+                df,
+                column,
+                column_rules["max"],
+                summary,
+                column_result,
+            )
+
+        if "allowed" in column_rules:
+            _check_allowed(
+                df,
+                column,
+                column_rules["allowed"],
+                summary,
+                column_result,
+            )
+
+        if column_rules.get("unique"):
+            _check_unique(
+                df,
+                column,
+                summary,
+                column_result,
+            )
+
+        results[column] = column_result
+                
+        if summary["rules_checked"]:
+            summary["validation_score"] = round(
+                (
+                    summary["rules_passed"]
+                    / summary["rules_checked"]
+                ) * 100,
+                2,
+            )
+
+    return {
+        "summary": summary,
+        "columns": results,
+    }

datra/cleaner.py

@@ -0,0 +1,74 @@
+from copy import deepcopy
+
+from datra.io import load, save
+from datra.defaults import DEFAULT_CLEANING_RULES
+from datra.cleaning.duplicates import remove_duplicates
+from datra.cleaning.missing import fill_missing
+from datra.cleaning.columns import standardize_column_names
+
+
+def clean(
+    data,
+    *,
+    rules=None,
+    drop_duplicates=None,
+    fill_numeric=None,
+    fill_categorical=None,
+    standardize_columns=None,
+    output=None,
+    format=None,
+):
+    df = load(data)
+
+    rules = _build_rules(
+            rules,
+            drop_duplicates=drop_duplicates,
+            fill_numeric=fill_numeric,
+            fill_categorical=fill_categorical,
+            standardize_columns=standardize_columns,
+        )
+
+    cleaned = df.copy()
+
+    if rules["duplicates"]["drop"]:
+        cleaned = remove_duplicates(cleaned)
+
+    missing = rules["missing"]
+    if any(value is not None for value in missing.values()):
+        cleaned = fill_missing(cleaned, missing)
+
+    if rules["columns"]["standardize"]:
+        cleaned = standardize_column_names(cleaned)
+
+    if output is not None:
+        save(cleaned, output, format)
+
+    return cleaned
+
+
+def _build_rules(
+    rules,
+    *,
+    drop_duplicates,
+    fill_numeric,
+    fill_categorical,
+    standardize_columns,
+):
+    merged = deepcopy(DEFAULT_CLEANING_RULES)
+
+    if rules is not None:
+        merged.update(rules)
+
+    if drop_duplicates is not None:
+        merged["duplicates"]["drop"] = drop_duplicates
+
+    if fill_numeric is not None:
+        merged["missing"]["numeric"] = fill_numeric
+
+    if fill_categorical is not None:
+        merged["missing"]["categorical"] = fill_categorical
+
+    if standardize_columns is not None:
+        merged["columns"]["standardize"] = standardize_columns
+
+    return merged

datra/cleaning/columns.py

@@ -0,0 +1,35 @@
+import re
+import pandas as pd
+
+
+def standardize_column_names(df: pd.DataFrame):
+    cleaned = df.copy()
+
+    cleaned.columns = [
+        _standardize(column)
+        for column in cleaned.columns
+    ]
+
+    return cleaned
+
+
+def _standardize(name: str) -> str:
+    name = name.strip()
+
+    #Ssplit acronym followed by a normal word.
+    # HTTPStatus -> HTTP_Status
+    name = re.sub(r"([A-Z]+)([A-Z][a-z])", r"\1_\2", name)
+
+    # Split lowercase/ditgit followed by uppercase
+    name = re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name)
+
+    # Replace any non-alphanumeric characters with underscores
+    name = re.sub(r"[^A-Za-z0-9]+", "_", name)
+
+    # Collapse repeated underscores
+    name = re.sub(r"_+", "_", name)
+
+    # Remove leading/trailing underscores.
+    name = name.strip("_")
+
+    return name.lower()

datra/cleaning/duplicates.py

@@ -0,0 +1,6 @@
+import pandas as pd
+
+
+def remove_duplicates(df: pd.DataFrame):
+
+    return df.drop_duplicates().copy()

datra/cleaning/missing.py

@@ -0,0 +1,56 @@
+import pandas as pd
+
+
+def _fill_numeric(df: pd.DataFrame, strategy):
+    numeric_columns = df.select_dtypes(include="number").columns
+
+    if numeric_columns.empty:
+        return df
+    
+    if strategy == "zero":
+        value = 0
+
+    elif strategy in ("mean", "median"):
+        value = df[numeric_columns].agg(strategy)
+
+    elif strategy == "mode":
+        mode_df = df[numeric_columns].mode()
+        value = mode_df.iloc[0] if not mode_df.empty else pd.Series(dtype="float64")
+
+
+    else: 
+        raise ValueError(f"Unknown numeric strategy '{strategy}'. Use 'mean', 'median', 'mode', or 'zero'.")
+
+    df[numeric_columns] = df[numeric_columns].fillna(value)
+
+
+
+def _fill_categorical(df: pd.DataFrame, strategy):
+    categorical_columns = df.select_dtypes(exclude="number").columns
+
+    if categorical_columns.empty:
+        return df
+    
+    if strategy == "mode":
+        mode_df = df[categorical_columns].mode()
+        value = mode_df.iloc[0] if not mode_df.empty else pd.Series(dtype="object")
+
+    else: 
+        raise ValueError(f"Unknown categorical strategy '{strategy}'. Use 'mode'.")
+
+    df[categorical_columns] = df[categorical_columns].fillna(value)
+
+
+def fill_missing(df: pd.DataFrame, rules: dict) -> pd.DataFrame:
+    cleaned = df.copy()
+
+    numeric_strategy = rules.get("numeric")
+    categorical_strategy = rules.get("categorical")
+
+    if numeric_strategy:
+        _fill_numeric(cleaned, numeric_strategy)
+
+    if categorical_strategy:
+        _fill_categorical(cleaned, categorical_strategy)
+
+    return cleaned

datra/defaults.py

@@ -0,0 +1,12 @@
+DEFAULT_CLEANING_RULES = {
+    "duplicates": {
+        "drop": True,
+    },
+    "missing": {
+        "numeric": None,
+        "categorical": None,
+    },
+    "columns": {
+        "standardize": True,
+    },
+}

datra/io/__init__.py

@@ -0,0 +1,4 @@
+from .load import load
+from .save import save
+
+__all__ = ["load", "save"]

datra/io/load.py

@@ -0,0 +1,34 @@
+from pathlib import Path
+
+import pandas as pd
+
+
+_READERS = {
+    ".csv": pd.read_csv,
+    ".xlsx": pd.read_excel,
+    ".xls": pd.read_excel,
+}
+
+
+def load(data):
+    if isinstance(data, pd.DataFrame):
+        return data.copy()
+
+    if not isinstance(data, (str, Path)):
+        raise TypeError(
+            f"Unsupported input type: {type(data).__name__}."
+        )
+
+    path = Path(data)
+
+    if not path.exists():
+        raise FileNotFoundError(f"File not found: {path}")
+
+    try:
+        reader = _READERS[path.suffix.lower()]
+    except KeyError as exc:
+        raise ValueError(
+            f"Unsupported file type: '{path.suffix}'."
+        ) from exc
+
+    return reader(path)

datra/io/save.py

@@ -0,0 +1,46 @@
+from pathlib import Path
+
+import pandas as pd
+
+
+def _save_csv(df: pd.DataFrame, path: Path):
+    df.to_csv(path, index=False)
+
+
+def _save_excel(df: pd.DataFrame, path: Path):
+    df.to_excel(path, index=False)
+
+
+_WRITERS = {
+    ".csv": _save_csv,
+    ".xlsx": _save_excel,
+    ".xls": _save_excel,
+}
+
+def _resolve_suffix(output: Path, format):
+    if format is not None:
+        suffix = "." + format.lower().lstrip(".")
+        output = output.with_suffix(suffix)
+    else:
+        suffix = output.suffix.lower()
+
+    return output, suffix
+
+def save(df: pd.DataFrame, output, format=None):
+    output = Path(output)
+
+    output, suffix = _resolve_suffix(output, format)
+    
+    if suffix not in _WRITERS:
+        supported = ", ".join(_WRITERS.keys())
+        raise ValueError(
+            f"Unsupported file format '{suffix}'. Supported formats are: {supported}"
+        )
+    
+    writer = _WRITERS[suffix]
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+
+    writer(df, output)
+
+    return output

datra/reports/__init__.py

@@ -0,0 +1,7 @@
+from .builder import build_report
+from .exporter import save_report
+
+__all__ = [
+    "build_report",
+    "save_report",
+]

datra/reports/builder.py

@@ -0,0 +1,35 @@
+from datetime import datetime
+
+
+def build_report(results: dict):
+    return {
+        "metadata": {
+            "generated_at": datetime.now().isoformat(),
+            "tool": "datra",
+        },
+
+        "summary": _build_summary(results),
+
+        "profile": results.get("profile", {}),
+
+        "checks": {
+            "completeness": results.get("completeness", {}),
+            "uniqueness": results.get("uniqueness", {}),
+            "outliers": results.get("outliers", {}),
+        },
+
+        "score": results.get("score", {}),
+    }
+
+
+def _build_summary(results: dict):
+    score = results.get("score", {})
+
+    return {
+        "dataset_quality_score": score.get("overall_score"),
+        "rows": results.get("profile", {}).get("rows"),
+        "columns": results.get("profile", {}).get("columns"),
+        "has_duplicates": bool(results.get("uniqueness", {}).get("duplicate_rows", 0)),
+        "has_missing_values": bool(results.get("completeness")),
+        "has_outliers": bool(results.get("outliers")),
+    }

datra/reports/exporter.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+from datetime import datetime
+
+from .templates import report_to_html
+
+
+def save_report(
+    report,
+    output="outputs",
+    format="json",
+):
+    output = Path(output)
+    output.mkdir(parents=True, exist_ok=True)
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    filename = f"datra_report_{timestamp}.{format}"
+
+    path = output / filename
+
+    if format == "json":
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(report, f, indent=4)
+
+    elif format == "html":
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(report_to_html(report))
+
+    else:
+        raise ValueError(
+            f"Unsupported report format '{format}'."
+        )
+
+    return path

datra/reports/templates.py

@@ -0,0 +1,26 @@
+import json
+
+
+def report_to_html(report: dict):
+    return f"""
+        <!DOCTYPE html>
+        <html>
+            <head>
+                <meta charset="utf-8">
+                <title>Datra Report</title>
+            </head>
+
+            <body>
+                <h1>Datra Audit Report</h1>
+
+                <h2>Summary</h2>
+                <pre>{json.dumps(report["summary"], indent=4)}</pre>
+
+                <h2>Score</h2>
+                <pre>{json.dumps(report["score"], indent=4)}</pre>
+
+                <h2>Checks</h2>
+                <pre>{json.dumps(report["checks"], indent=4)}</pre>
+            </body>
+        </html>
+        """

datra/scoring/score.py

@@ -0,0 +1,51 @@
+def calculate_score(results: dict):
+    scores = {}
+    
+    comp = results.get("completeness", {})
+    if comp:
+        ratios = [
+            v["completeness_ratio"]
+            for v in comp.values()
+        ]
+        scores["completeness"] = (
+            sum(ratios) / len(ratios)
+            if ratios
+            else 0
+        )
+    else:
+        scores["completeness"] = 0
+
+
+    # lower duplicates = better
+    uniq = results.get("uniqueness", {})
+    if uniq:
+        dup_ratio = uniq.get("duplicate_ratio", 1)
+        scores["uniqueness"] = 1 - dup_ratio
+    else:
+        scores["uniqueness"] = 0
+
+
+    out = results.get("outliers", {})
+    if out:
+        ratios = [
+            v["outlier_ratio"]
+            for v in out.values()
+        ]
+        avg_outlier = sum(ratios) / len(ratios)
+        scores["outliers"] = 1 - avg_outlier
+    else:
+        scores["outliers"] = 1
+    
+
+    overall_score = round(
+        sum(scores.values()) / len(scores),
+        2
+    )
+
+    return {
+        "scores": { 
+            k: round(v, 2)
+            for k, v in scores.items()
+        },
+        "overall_score": overall_score,
+    }

datra-0.1.0.dist-info/METADATA

@@ -0,0 +1,338 @@
+Metadata-Version: 2.4
+Name: datra
+Version: 0.1.0
+Summary: A lightweight Python library for cleaning, auditing, and validating tabular data.
+Author-email: Raphael <raphaeljames897@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 Raphael James
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/Raphaelj1/datra
+Project-URL: Repository, https://github.com/Raphaelj1/datra
+Project-URL: Issues, https://github.com/Raphaelj1/datra/issues
+Keywords: data-cleaning,data-quality,validation,pandas,data-analysis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pandas<3.0,>=2.0
+Requires-Dist: openpyxl>=3.1
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# Datra
+
+A lightweight Python library for cleaning, auditing, and validating tabular data. It helps data scientists, analysts, and engineers quickly identify data quality issues, clean datasets using simple rules, and generate reports.
+
+## Why Datra?
+
+Data quality problems often consume more time than analysis itself. Missing values, duplicate records, inconsistent column names, and invalid entries can silently affect downstream models and business decisions.
+
+Datra provides a simple workflow for understanding and improving dataset quality before analysis or machine learning.
+
+With Datra, you can:
+
+- Audit datasets to identify quality issues.
+- Clean data using configurable rules.
+- Validate datasets against business rules.
+- Generate JSON and HTML quality reports.
+- Work directly with Pandas DataFrames or CSV and Excel files.
+
+## Features
+
+- Dataset profiling
+- Missing value analysis
+- Duplicate detection
+- Outlier detection (IQR-based)
+- Rule-based data validation
+- Automated data quality scoring
+- Configurable data cleaning
+- Column name standardization
+- Support for Pandas DataFrames
+- CSV and Excel file support
+- JSON and HTML report generation
+- Save cleaned datasets directly to disk
+
+## Installation
+
+Install Datra from PyPI:
+
+```bash
+pip install datra
+```
+
+Or install the latest development version:
+
+```bash
+git clone https://github.com/raphaelj1/datra.git
+
+cd datra
+
+pip install -e .
+```
+
+## Quick Start
+
+### Clean a dataset
+
+```python
+from datra import clean
+
+cleaned = clean(
+    "patients.csv",
+    drop_duplicates=True,
+    fill_numeric="median",
+    fill_categorical="mode",
+    standardize_columns=True,
+)
+```
+
+### Audit a dataset
+
+```python
+from datra import Audit
+
+audit = Audit("patients.csv")
+
+print(audit.profile)
+print(audit.score)
+```
+
+### Validate a dataset
+
+```python
+rules = {
+    "Age": {
+        "min": 0,
+        "max": 120,
+    },
+    "Gender": {
+        "allowed": [
+            "Male",
+            "Female",
+        ],
+    },
+}
+
+report = audit.validate(rules)
+```
+
+## Cleaning Data
+
+The `clean()` function applies one or more cleaning operations to a dataset and returns a new DataFrame. It accepts either a Pandas DataFrame or the path to a CSV or Excel file.
+
+### Using keyword arguments
+
+```python
+from datra import clean
+
+cleaned = clean(
+    "patients.csv",
+    drop_duplicates=True,
+    fill_numeric="median",
+    fill_categorical="mode",
+    standardize_columns=True,
+)
+```
+
+### Using cleaning rules
+
+```python
+rules = {
+    "duplicates": {
+        "drop": True,
+    },
+    "missing": {
+        "numeric": "median",
+        "categorical": "mode",
+    },
+    "columns": {
+        "standardize": True,
+    },
+}
+
+cleaned = clean("patients.csv", rules=rules)
+```
+
+### Save the cleaned dataset
+
+```python
+clean(
+    "patients.csv",
+    drop_duplicates=True,
+    output="cleaned_patients.xlsx",
+)
+```
+
+## Auditing Data
+
+Create an audit object to inspect dataset quality.
+
+```python
+from datra import Audit
+
+audit = Audit("patients.csv")
+```
+
+Retrieve individual quality checks.
+
+```python
+audit.profile
+
+audit.completeness
+
+audit.uniqueness
+
+audit.outliers
+
+audit.score
+```
+
+Or access all audit results at once.
+
+```python
+audit.results
+```
+
+## Validation
+
+Validate datasets against custom business rules.
+
+```python
+rules = {
+    "Age": {
+        "min": 0,
+        "max": 120,
+    },
+    "Patient ID": {
+        "unique": True,
+    },
+    "Gender": {
+        "allowed": [
+            "Male",
+            "Female",
+        ],
+    },
+}
+
+report = audit.validate(rules)
+```
+
+Validation returns a structured report describing which checks passed, which failed, and the number of violations for each rule.
+
+## Reports
+
+Build a data quality report as a Python dictionary.
+
+```python
+from datra import Audit
+
+audit = Audit("patients.csv")
+
+report = audit.build_report()
+```
+
+Save the report as JSON.
+
+```python
+audit.save_report(
+    format="json",
+)
+```
+
+Or save it as an HTML report.
+
+```python
+audit.save_report(
+    format="html",
+)
+```
+
+## Supported File Formats
+
+Datra supports both Pandas DataFrames and common tabular file formats.
+
+| Input            | Supported |
+| ---------------- | --------- |
+| Pandas DataFrame | ✅        |
+| CSV              | ✅        |
+| Excel (.xlsx)    | ✅        |
+| Excel (.xls)     | ✅        |
+
+### Report Formats
+
+| Format | Supported  |
+| ------ | ---------- |
+| JSON   | ✅         |
+| HTML   | ✅         |
+| PDF    | 🚧 Planned |
+
+## Project Structure
+
+```
+datra/
+├── datra/              # Library source code
+├── examples/           # Example usage
+├── tests/
+├── pyproject.toml
+├── README.md
+└── LICENSE
+```
+
+## Roadmap
+
+Planned improvements include:
+
+- PDF report generation
+- Command-line interface (CLI)
+- Additional cleaning operations
+- Additional validation rules
+- More data quality checks
+- Interactive HTML reports
+- Support for additional file formats
+
+## Contributing
+
+Contributions, feature requests, and bug reports are welcome.
+
+If you would like to contribute:
+
+1. Fork the repository.
+2. Create a new feature branch.
+3. Commit your changes.
+4. Open a pull request.
+
+Please ensure all tests pass before submitting a pull request.
+
+## License
+
+This project is licensed under the MIT License.

datra-0.1.0.dist-info/RECORD

@@ -0,0 +1,28 @@
+datra/__init__.py,sha256=1hClFgDmV-XDtPolfJHiIYsnkiSXCnoWLxKmk-FQZiw,84
+datra/audit.py,sha256=6R13Pn4gDvDcNEr0cs2s4UdwcDU3m7_Ph1lxQZDE7_A,1813
+datra/cleaner.py,sha256=eBLk_aKj6Ot-VKwTRUV7m-l9rZbNhwW0WWMKcU8sKYs,1850
+datra/defaults.py,sha256=nMpeF2HUm72zBfnFxWfBAKf_uZEr5zkL-xqim1kfePI,219
+datra/checks/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datra/checks/completeness.py,sha256=Mmj2WpVvr6BtoGd7s5ZIPeEFKRPhGoXhV_Y5IJf4QzA,433
+datra/checks/outliers.py,sha256=sSui1_-nFxRNEC2jnuKn3jrkDn6lhFSNcI9ZDm2e3mI,906
+datra/checks/profile.py,sha256=FjTwEFHjLh0DdhJkQoIaGOfpsmZfkqFJ-fzFJACX8Z4,1335
+datra/checks/uniqueness.py,sha256=O8nLFvQzj7ryEn_9kxcBqEXn3yUATHmSpKco6GTaUvQ,512
+datra/checks/validate.py,sha256=aaCZvnLPt7txUMtyB_SxodKVa2mS047ChG9lVFjVkiI,3441
+datra/cleaning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datra/cleaning/columns.py,sha256=4YSTWOhxa0sVBZNyNP6Yq0ONz4rY7cEPMda8RSj9PxM,844
+datra/cleaning/duplicates.py,sha256=pEOR_Zo4TnITPSck64ohmrFc0AWz0TTxjjEYBJ6YS5g,107
+datra/cleaning/missing.py,sha256=yrtC265kicr7iogGXJsFv7jZb_uOq_-T1mHNaYx0INg,1598
+datra/io/__init__.py,sha256=2gVWbsNF1AnyonLfvIANNxC0kKipQZf0gUv4KO2jsWk,76
+datra/io/load.py,sha256=pWVexMzIfeVN3xvYClFLbO415_ctuodLtvz-B1FM4MA,718
+datra/io/save.py,sha256=zB54SYGyjRjteyXj5k_02c1RlJIQZTL9fiesWJlS-s4,1053
+datra/reports/__init__.py,sha256=n-8S8-Ru9tKkuCyKaXzsEerFCIb-wBh9taHAdTBu444,127
+datra/reports/builder.py,sha256=Od1S7ozc4w1eeGyc5ZA8K2jTpMyIXX8xlN1fD-cguok,1058
+datra/reports/exporter.py,sha256=uv0m1ELxH2y7qKQP-SZnlv0ihIxK396qDOCs8YIKT1A,791
+datra/reports/templates.py,sha256=pzvTMmN1SYupLZ3J8A6bzRzyCUCXxBRCNxeRZAhLGf4,664
+datra/scoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+datra/scoring/score.py,sha256=oOnZuKIWEkiaV5Ae_KMtg1Vl29Rkj9ttLMlXuyI31iU,1189
+datra-0.1.0.dist-info/licenses/LICENSE,sha256=06G7x2RjMHSDF3YlizZYiWN6NKucfVoKIfIM9YLmZQQ,1091
+datra-0.1.0.dist-info/METADATA,sha256=BGNss3O0t5tAj42HNxjvnc85YF4xvW-WzclbfR4IBjc,8036
+datra-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+datra-0.1.0.dist-info/top_level.txt,sha256=tikJ6dyoHKVnA0xDo5hELjedEDb-NxP4IURNI1FQpaE,6
+datra-0.1.0.dist-info/RECORD,,

datra-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
+

datra-0.1.0.dist-info/licenses/LICENSE

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

datra-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+datra