csvguard 0.1.0__py3-none-any.whl

csvguard/__init__.py

@@ -0,0 +1,12 @@
+"""
+csvguard: The Fast, Terminal-First Data Quality & Cleaning CLI for Python
+"""
+
+__version__ = "0.1.0"
+__author__ = "Sumit"
+__license__ = "MIT"
+
+from .profiler import audit
+from .cleaner import clean
+
+__all__ = ["audit", "clean", "__version__"]

csvguard/cleaner.py

@@ -0,0 +1,97 @@
+import os
+import re
+import pandas as pd
+import numpy as np
+
+def to_snake_case(text):
+    text = str(text).strip()
+    text = re.sub(r'[^\w\s-]', '', text)
+    text = re.sub(r'[-\s]+', '_', text)
+    return text.lower()
+
+def clean(
+    file_path,
+    output_path=None,
+    standardize_headers=True,
+    drop_duplicates=True,
+    impute_numeric="median",
+    impute_categorical="Unknown",
+    clip_outliers=False
+):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+        
+    df = pd.read_csv(file_path)
+    orig_rows, orig_cols = df.shape
+    changes = []
+    
+    # 1. Standardize Headers
+    if standardize_headers:
+        old_cols = list(df.columns)
+        new_cols = [to_snake_case(c) for c in old_cols]
+        renamed_count = sum(1 for o, n in zip(old_cols, new_cols) if o != n)
+        df.columns = new_cols
+        if renamed_count > 0:
+            changes.append(f"Standardized {renamed_count} column header(s) to snake_case")
+            
+    # 2. Drop Duplicates
+    if drop_duplicates:
+        dups = df.duplicated().sum()
+        if dups > 0:
+            df = df.drop_duplicates()
+            changes.append(f"Removed {dups} duplicate row(s)")
+            
+    # 3. Impute Numeric Columns
+    if impute_numeric in ["median", "mean"]:
+        num_imputed = 0
+        for col in df.select_dtypes(include=[np.number]).columns:
+            missing = df[col].isna().sum()
+            if missing > 0:
+                val = df[col].median() if impute_numeric == "median" else df[col].mean()
+                df[col] = df[col].fillna(round(val, 2))
+                num_imputed += missing
+        if num_imputed > 0:
+            changes.append(f"Imputed {num_imputed} missing numeric values using {impute_numeric}")
+            
+    # 4. Impute Categorical Columns
+    if impute_categorical:
+        cat_imputed = 0
+        for col in df.select_dtypes(include=['object', 'category']).columns:
+            missing = df[col].isna().sum()
+            if missing > 0:
+                df[col] = df[col].fillna(impute_categorical)
+                cat_imputed += missing
+        if cat_imputed > 0:
+            changes.append(f"Imputed {cat_imputed} missing text values with '{impute_categorical}'")
+            
+    # 5. Clip Outliers (Optional)
+    if clip_outliers:
+        outliers_clipped = 0
+        for col in df.select_dtypes(include=[np.number]).columns:
+            if df[col].dropna().shape[0] > 4:
+                q1 = df[col].quantile(0.25)
+                q3 = df[col].quantile(0.75)
+                iqr = q3 - q1
+                lower = q1 - 1.5 * iqr
+                upper = q3 + 1.5 * iqr
+                
+                mask = (df[col] < lower) | (df[col] > upper)
+                outliers_clipped += int(mask.sum())
+                df[col] = df[col].clip(lower, upper)
+        if outliers_clipped > 0:
+            changes.append(f"Clipped {outliers_clipped} extreme outlier(s) using IQR fences")
+            
+    # Export
+    if not output_path:
+        base, ext = os.path.splitext(file_path)
+        output_path = f"{base}_cleaned{ext}"
+        
+    df.to_csv(output_path, index=False)
+    
+    return {
+        "output_path": output_path,
+        "original_rows": orig_rows,
+        "final_rows": df.shape[0],
+        "columns": df.shape[1],
+        "changes": changes
+    }

csvguard/cli.py

@@ -0,0 +1,87 @@
+import sys
+import argparse
+
+# Ensure UTF-8 output encoding across Windows terminals
+if sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except Exception:
+        pass
+
+from rich.console import Console
+from .profiler import audit
+from .cleaner import clean
+from .reporter import render_terminal_audit, export_markdown_report
+from . import __version__
+
+console = Console(force_terminal=True, legacy_windows=False)
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="csvguard",
+        description="csvguard: The Fast, Terminal-First Data Quality & Cleaning CLI"
+    )
+    parser.add_argument("-v", "--version", action="version", version=f"csvguard {__version__}")
+    
+    subparsers = parser.add_subparsers(dest="command", help="Available sub-commands")
+    
+    # 1. audit sub-command
+    audit_parser = subparsers.add_parser("audit", help="Audit a CSV file and display an interactive terminal health report")
+    audit_parser.add_argument("file", help="Path to the CSV file to audit")
+    
+    # 2. clean sub-command
+    clean_parser = subparsers.add_parser("clean", help="Clean, sanitize, and impute issues in a CSV file")
+    clean_parser.add_argument("file", help="Path to the CSV file to clean")
+    clean_parser.add_argument("-o", "--output", help="Output path for the cleaned CSV file")
+    clean_parser.add_argument("--auto", action="store_true", help="Apply standard best-practice cleaning (drop dups, snake_case headers, median imputation)")
+    clean_parser.add_argument("--no-duplicates", action="store_true", help="Do not drop duplicates")
+    clean_parser.add_argument("--impute-num", choices=["median", "mean"], default="median", help="Method for missing numeric imputation")
+    clean_parser.add_argument("--impute-cat", default="Unknown", help="Value to fill missing categorical cells with")
+    clean_parser.add_argument("--clip-outliers", action="store_true", help="Clip extreme numeric outliers using IQR fences")
+    
+    # 3. report sub-command
+    report_parser = subparsers.add_parser("report", help="Generate and export a Markdown health report")
+    report_parser.add_argument("file", help="Path to the CSV file to inspect")
+    report_parser.add_argument("-o", "--output", default="csvguard_report.md", help="Output path for Markdown report (default: csvguard_report.md)")
+    
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(0)
+        
+    try:
+        if args.command == "audit":
+            profile = audit(args.file)
+            render_terminal_audit(profile)
+            
+        elif args.command == "clean":
+            result = clean(
+                file_path=args.file,
+                output_path=args.output,
+                standardize_headers=True,
+                drop_duplicates=not args.no_duplicates,
+                impute_numeric=args.impute_num,
+                impute_categorical=args.impute_cat,
+                clip_outliers=args.clip_outliers or args.auto
+            )
+            console.print("\n[bold green]Cleaning Successfully Completed![/bold green]")
+            console.print(f"[bold]Saved cleaned file to:[/bold] [cyan]{result['output_path']}[/cyan]")
+            console.print(f"[bold]Rows:[/bold] {result['original_rows']} -> [green]{result['final_rows']}[/green] | [bold]Columns:[/bold] {result['columns']}\n")
+            console.print("[bold]Modifications applied:[/bold]")
+            for ch in result["changes"]:
+                console.print(f"  * [green]{ch}[/green]")
+            console.print("")
+            
+        elif args.command == "report":
+            profile = audit(args.file)
+            out_path = export_markdown_report(profile, args.output)
+            console.print(f"\n[bold green]Audit Report Exported Successfully:[/bold green] [cyan]{out_path}[/cyan]\n")
+            
+    except Exception as e:
+        console.print(f"\n[bold red]Error:[/bold red] {str(e)}\n")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

csvguard/profiler.py

@@ -0,0 +1,119 @@
+import os
+import pandas as pd
+import numpy as np
+
+def detect_delimiter(file_path):
+    with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+        first_line = f.readline()
+        if ';' in first_line and ',' not in first_line:
+            return ';'
+        elif '\t' in first_line:
+            return '\t'
+        elif '|' in first_line:
+            return '|'
+    return ','
+
+def audit(file_path):
+    if not os.path.exists(file_path):
+        raise FileNotFoundError(f"File not found: {file_path}")
+        
+    delimiter = detect_delimiter(file_path)
+    try:
+        df = pd.read_csv(file_path, sep=delimiter, encoding='utf-8')
+    except UnicodeDecodeError:
+        df = pd.read_csv(file_path, sep=delimiter, encoding='latin1')
+        
+    num_rows, num_cols = df.shape
+    file_size_kb = round(os.path.getsize(file_path) / 1024, 2)
+    
+    # 1. Duplicates
+    dup_count = int(df.duplicated().sum())
+    dup_pct = round((dup_count / num_rows) * 100, 2) if num_rows > 0 else 0.0
+    
+    # 2. Column Metrics & Anomalies
+    col_profiles = []
+    total_missing_cells = 0
+    total_outliers = 0
+    header_issues = 0
+    
+    for col in df.columns:
+        col_clean = str(col).strip()
+        if col != col_clean or ' ' in col_clean:
+            header_issues += 1
+            
+        series = df[col]
+        missing_count = int(series.isna().sum())
+        total_missing_cells += missing_count
+        missing_pct = round((missing_count / num_rows) * 100, 2) if num_rows > 0 else 0.0
+        unique_count = int(series.nunique())
+        
+        # Outlier detection for numeric columns (IQR Method)
+        outlier_count = 0
+        is_numeric = pd.api.types.is_numeric_dtype(series)
+        col_type = "Numeric" if is_numeric else "Text / Categorical"
+        
+        if is_numeric and series.dropna().shape[0] > 4:
+            clean_series = series.dropna()
+            q1 = clean_series.quantile(0.25)
+            q3 = clean_series.quantile(0.75)
+            iqr = q3 - q1
+            lower_bound = q1 - 1.5 * iqr
+            upper_bound = q3 + 1.5 * iqr
+            outlier_mask = (clean_series < lower_bound) | (clean_series > upper_bound)
+            outlier_count = int(outlier_mask.sum())
+            total_outliers += outlier_count
+            
+        status = "Healthy"
+        if missing_pct > 20.0 or outlier_count > (0.05 * num_rows):
+            status = "Warning"
+        elif missing_pct > 50.0:
+            status = "Critical"
+            
+        col_profiles.append({
+            "name": str(col),
+            "type": col_type,
+            "missing_count": missing_count,
+            "missing_pct": missing_pct,
+            "unique_count": unique_count,
+            "outlier_count": outlier_count,
+            "status": status
+        })
+        
+    # 3. Data Health Score Calculation (0 to 100)
+    total_cells = max(1, num_rows * num_cols)
+    missing_ratio = total_missing_cells / total_cells
+    
+    score = 100.0
+    score -= (missing_ratio * 100.0 * 0.45)           # Up to 45 pts penalty for missing data
+    score -= min(25.0, dup_pct * 1.5)                 # Up to 25 pts penalty for duplicates
+    score -= min(15.0, (total_outliers / total_cells) * 100.0 * 2.0)  # Up to 15 pts for outliers
+    score -= min(15.0, header_issues * 2.5)           # Up to 15 pts for bad headers
+    
+    final_score = int(max(10, min(100, round(score))))
+    
+    if final_score >= 90:
+        grade = "A (Excellent)"
+    elif final_score >= 80:
+        grade = "B (Good, Minor Issues)"
+    elif final_score >= 70:
+        grade = "C (Fair, Needs Attention)"
+    elif final_score >= 60:
+        grade = "D (Poor Quality)"
+    else:
+        grade = "F (Critical Action Needed)"
+        
+    return {
+        "file_name": os.path.basename(file_path),
+        "file_path": file_path,
+        "file_size_kb": file_size_kb,
+        "rows": num_rows,
+        "cols": num_cols,
+        "duplicates": dup_count,
+        "dup_pct": dup_pct,
+        "total_missing": total_missing_cells,
+        "total_outliers": total_outliers,
+        "header_issues": header_issues,
+        "health_score": final_score,
+        "grade": grade,
+        "columns": col_profiles
+    }

csvguard/reporter.py

@@ -0,0 +1,147 @@
+import sys
+import os
+
+# Ensure UTF-8 output encoding across Windows terminals
+if sys.stdout.encoding != 'utf-8':
+    try:
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    except Exception:
+        pass
+
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import box
+
+console = Console(force_terminal=True, legacy_windows=False)
+
+def render_terminal_audit(profile):
+    score = profile["health_score"]
+    grade = profile["grade"]
+    
+    if score >= 85:
+        score_badge = f"[bold white on green] {score}/100 [/bold white on green] {grade}"
+    elif score >= 70:
+        score_badge = f"[bold black on yellow] {score}/100 [/bold black on yellow] {grade}"
+    else:
+        score_badge = f"[bold white on red] {score}/100 [/bold white on red] {grade}"
+        
+    # Top Banner
+    console.print("\n")
+    console.print(Panel(
+        f"[bold white][SHIELD] csvguard Audit:[/bold white] [cyan]{profile['file_name']}[/cyan] ({profile['file_size_kb']} KB)\n"
+        f"Data Health Score: {score_badge}",
+        box=box.ROUNDED,
+        border_style="blue"
+    ))
+    
+    # Summary Metrics Table
+    summary_table = Table(box=box.SIMPLE_HEAD, show_header=True, header_style="bold cyan")
+    summary_table.add_column("Rows", justify="center")
+    summary_table.add_column("Columns", justify="center")
+    summary_table.add_column("Duplicate Rows", justify="center")
+    summary_table.add_column("Missing Cells", justify="center")
+    summary_table.add_column("Outliers (IQR)", justify="center")
+    summary_table.add_column("Header Issues", justify="center")
+    
+    dup_str = f"[red]{profile['duplicates']}[/red]" if profile['duplicates'] > 0 else "[green]0[/green]"
+    miss_str = f"[red]{profile['total_missing']}[/red]" if profile['total_missing'] > 0 else "[green]0[/green]"
+    out_str = f"[yellow]{profile['total_outliers']}[/yellow]" if profile['total_outliers'] > 0 else "[green]0[/green]"
+    head_str = f"[yellow]{profile['header_issues']}[/yellow]" if profile['header_issues'] > 0 else "[green]0[/green]"
+    
+    summary_table.add_row(
+        str(profile['rows']),
+        str(profile['cols']),
+        dup_str,
+        miss_str,
+        out_str,
+        head_str
+    )
+    console.print(summary_table)
+    
+    # Detailed Column Breakdown Table
+    col_table = Table(
+        title="Column-by-Column Deep Health Inspection",
+        box=box.ROUNDED,
+        border_style="dim",
+        header_style="bold blue"
+    )
+    col_table.add_column("#", justify="right", style="dim")
+    col_table.add_column("Column Name", justify="left", style="bold")
+    col_table.add_column("Inferred Type", justify="center")
+    col_table.add_column("Missing (%)", justify="right")
+    col_table.add_column("Uniques", justify="right")
+    col_table.add_column("Outliers", justify="right")
+    col_table.add_column("Health Status", justify="center")
+    
+    for idx, c in enumerate(profile["columns"], start=1):
+        if c["missing_pct"] == 0:
+            m_text = "[green]0% (0)[/green]"
+        elif c["missing_pct"] < 20:
+            m_text = f"[yellow]{c['missing_pct']}% ({c['missing_count']})[/yellow]"
+        else:
+            m_text = f"[bold red]{c['missing_pct']}% ({c['missing_count']})[/bold red]"
+            
+        o_text = f"[yellow]{c['outlier_count']}[/yellow]" if c['outlier_count'] > 0 else "[green]0[/green]"
+        
+        if c["status"] == "Healthy":
+            status_text = "[green][OK] Healthy[/green]"
+        elif c["status"] == "Warning":
+            status_text = "[yellow][WARN] Warning[/yellow]"
+        else:
+            status_text = "[bold red][CRIT] Critical[/bold red]"
+            
+        col_table.add_row(
+            str(idx),
+            c["name"],
+            c["type"],
+            m_text,
+            str(c["unique_count"]),
+            o_text,
+            status_text
+        )
+        
+    console.print(col_table)
+    
+    if score < 90:
+        console.print("\n[bold yellow]Recommended Action:[/bold yellow] Run [bold cyan]csvguard clean <filename> --auto[/bold cyan] to automatically fix duplicates, sanitize headers, and impute missing values!\n")
+    else:
+        console.print("\n[bold green]Great news![/bold green] Your dataset meets high quality standards.\n")
+
+def export_markdown_report(profile, output_file="csvguard_report.md"):
+    md = f"""# csvguard Data Quality Report
+
+- **File Analyzed:** `{profile['file_name']}`
+- **File Size:** {profile['file_size_kb']} KB
+- **Health Score:** **{profile['health_score']}/100** ({profile['grade']})
+- **Total Records:** {profile['rows']} rows, {profile['cols']} columns
+
+---
+
+## Summary Metrics
+
+| Metric | Measured Value |
+|:---|:---:|
+| **Total Rows** | {profile['rows']} |
+| **Total Columns** | {profile['cols']} |
+| **Duplicate Rows** | {profile['duplicates']} ({profile['dup_pct']}%) |
+| **Total Missing Cells** | {profile['total_missing']} |
+| **Statistical Outliers (IQR)** | {profile['total_outliers']} |
+| **Header Formatting Issues** | {profile['header_issues']} |
+
+---
+
+## Column Health Matrix
+
+| Column Name | Inferred Type | Missing Count | Missing (%) | Unique Values | Outliers | Status |
+|:---|:---|:---:|:---:|:---:|:---:|:---:|
+"""
+    for c in profile["columns"]:
+        md += f"| `{c['name']}` | {c['type']} | {c['missing_count']} | {c['missing_pct']}% | {c['unique_count']} | {c['outlier_count']} | {c['status']} |\n"
+
+    md += "\n---\n*Generated autonomously by [csvguard](https://github.com/your-username/csvguard).*"
+    
+    with open(output_file, "w", encoding="utf-8") as f:
+        f.write(md)
+    return output_file

csvguard-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: csvguard
+Version: 0.1.0
+Summary: The Fast, Terminal-First Data Quality & Cleaning CLI
+Home-page: https://github.com/your-username/csvguard
+Author: Sumit
+Author-email: Sumit <sumit.developer@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: rich>=12.0.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🛡️ csvguard
+
+> **The Fast, Terminal-First Data Quality Profiler & Cleaning CLI for Python.**
+
+[![PyPI Version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+
+Stop writing 40 lines of boilerplate Pandas code just to inspect missing values, bad headers, duplicate rows, and statistical outliers in messy CSV files. 
+
+`csvguard` gives you a **CIBIL-style Data Health Score (0-100)**, an interactive terminal dashboard, and one-command automated data cleaning.
+
+---
+
+## ✨ Features
+
+- 🩺 **Instant Health Score (0-100):** Comprehensive weighted evaluation of missing data ratios, duplicate rows, IQR outliers, and header hygiene.
+- 🎨 **Rich Terminal Dashboard:** Color-coded tables, status indicators, and progress spinners directly inside your shell.
+- 🧹 **Automated Autonomous Cleaning:** Drop duplicates, sanitize column headers to `snake_case`, and impute missing numerical/categorical values with a single command.
+- 📈 **Statistical Outlier Detection:** Identifies extreme values using Tukey's Interquartile Range (IQR) fences.
+- 📄 **Markdown & CI/CD Export:** Generate markdown audit reports suitable for GitHub PRs and automated data validation pipelines.
+- ⚡ **Dual Interface:** Use as a standalone Command-Line Tool (`csvguard`) or as a Python library (`import csvguard`).
+
+---
+
+## 🚀 Installation
+
+### Via PyPI (Recommended):
+```bash
+pip install csvguard
+```
+
+### From Source (Local Development):
+```bash
+git clone https://github.com/your-username/csvguard.git
+cd csvguard
+pip install -e .
+```
+
+---
+
+## 💻 CLI Usage
+
+### 1. Audit a CSV File (Health Checkup):
+```bash
+csvguard audit data.csv
+```
+
+### 2. Auto-Clean and Sanitize Data:
+```bash
+csvguard clean messy.csv --auto -o cleaned.csv
+```
+This automatically:
+- Sanitizes headers (`  Annual Income  ` ➔ `annual_income`)
+- Removes exact duplicate records
+- Imputes missing numerical values with column medians
+- Fills missing text fields with `'Unknown'`
+
+### 3. Generate a Markdown Documentation Report:
+```bash
+csvguard report data.csv -o DATA_QUALITY_REPORT.md
+```
+
+---
+
+## 🐍 Python Library Usage
+
+You can also import `csvguard` directly in your machine learning scripts or Jupyter Notebooks:
+
+```python
+import csvguard as cg
+
+# 1. Audit dataset
+profile = cg.audit("samples/messy_sample.csv")
+print(f"Health Score: {profile['health_score']}/100 ({profile['grade']})")
+print(f"Duplicates: {profile['duplicates']}")
+
+# 2. Clean dataset programmatically
+res = cg.clean("samples/messy_sample.csv", output_path="clean.csv", impute_numeric="median")
+print(f"Cleaned dataset saved to: {res['output_path']}")
+```
+
+---
+
+## 📦 How to Publish to PyPI (For Maintainers)
+
+1. Build the distribution package:
+```bash
+python -m pip install --upgrade build twine
+python -m build
+```
+
+2. Upload to PyPI:
+```bash
+python -m twine upload dist/*
+```
+
+---
+
+## 📄 License
+Distributed under the [MIT License](LICENSE).

csvguard-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+csvguard/__init__.py,sha256=qucuUOWUVN9ASrDTKt6BAl183jOX1azJFMsIfwKYYxc,247
+csvguard/cleaner.py,sha256=-UONqM2VvfhLCyZHFu-gZOZlI9mmB9Ejsh4soQJnF2g,3350
+csvguard/cli.py,sha256=7yofHbsCXoCez_CuE0FBPOg8Zhp_dJVcLkd4aQedsII,4116
+csvguard/profiler.py,sha256=3Vtz27Urv33u61Znt9dnutS4GNogQ1J9plorO9KtT7g,4200
+csvguard/reporter.py,sha256=mqbRkD_vddoD0a3x-K9NLboUMayxXIbNNoUX7DETYIQ,5696
+csvguard-0.1.0.dist-info/METADATA,sha256=V1KqkRplqjSTRUW8z8JVJC1vA35OUdsKVKx9W3bmjWA,3964
+csvguard-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+csvguard-0.1.0.dist-info/entry_points.txt,sha256=GYDRDnlY7XDIie39t0wxPyIlnAWxPX-F2Jrt65_OJ5s,47
+csvguard-0.1.0.dist-info/top_level.txt,sha256=MJ8hyTMoKNsjuCdEd8YU2jOvKSi11D082DUOUW9qlFo,9
+csvguard-0.1.0.dist-info/RECORD,,

csvguard-0.1.0.dist-info/WHEEL

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

csvguard-0.1.0.dist-info/entry_points.txt

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

csvguard-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+csvguard