devg-humanerror 0.1.0__tar.gz

devg_humanerror-0.1.0/LICENSE.txt

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

devg_humanerror-0.1.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: devg-humanerror
+Version: 0.1.0
+Summary: Automatic correction of human-entry errors in tabular data
+Author: Dev Ganjawalla
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+\# devg-humanerror
+
+
+
+A tiny Python library to rescue your datasets from human data-entry errors 😎  
+
+Created by Dev Ganjawalla because finger slips happen.
+
+
+
+\## Features
+
+\- Detect repeated digits like 777 → 77.7
+
+\- Leading-digit corrections like 222 → 122
+
+\- Prechecks for symmetry, moderate spread, unimodal clusters
+
+\- Temperature parameter to adjust aggressiveness
+
+
+
+\## Installation
+
+
+
+```bash
+
+pip install devg-humanerror
+
+
+

devg_humanerror-0.1.0/README.md

@@ -0,0 +1,32 @@
+\# devg-humanerror
+
+
+
+A tiny Python library to rescue your datasets from human data-entry errors 😎  
+
+Created by Dev Ganjawalla because finger slips happen.
+
+
+
+\## Features
+
+\- Detect repeated digits like 777 → 77.7
+
+\- Leading-digit corrections like 222 → 122
+
+\- Prechecks for symmetry, moderate spread, unimodal clusters
+
+\- Temperature parameter to adjust aggressiveness
+
+
+
+\## Installation
+
+
+
+```bash
+
+pip install devg-humanerror
+
+
+

devg_humanerror-0.1.0/devg_humanerror/__init__.py

@@ -0,0 +1 @@
+from .core import SafeCorrector

devg_humanerror-0.1.0/devg_humanerror/core.py

@@ -0,0 +1,138 @@
+"""
+Core logic for devg_humanerror.
+A lightweight, transparent heuristic to detect and correct likely
+human data-entry mistakes (e.g., finger slips like 222 → 122 or 777 → 77.7).
+
+This is designed for tabular numeric columns (e.g., lab values).
+It is heuristic — not a statistical guarantee.
+"""
+
+import pandas as pd
+import numpy as np
+
+
+class SafeCorrector:
+    def __init__(self, temperature: float = 1.0):
+        """
+        Parameters
+        ----------
+        temperature : float
+            Controls how aggressive the corrections are.
+            > 1.0  → more tolerant (fewer corrections)
+            < 1.0  → more aggressive (more corrections)
+        """
+        self.temperature = float(temperature)
+
+    # ---------- PRECHECKS ----------
+    def _data_ok_for_correction(self, s: pd.Series) -> bool:
+        """
+        Decide whether a column is reasonable to run human-error corrections on.
+        Returns False if data look too pathological (very skewed, multimodal, or extreme spread).
+        """
+        s = s.dropna()
+        if len(s) < 5:
+            return False
+
+        mean = s.mean()
+        std = s.std()
+        median = s.median()
+
+        # 1) avoid near-zero means (ratios, percentages, etc.)
+        if abs(mean) < 1e-6:
+            return False
+
+        # 2) reject extremely skewed data
+        skew = s.skew()
+        if abs(skew) > 2:
+            return False
+
+        # 3) reject columns with extreme spread
+        if std > abs(mean) * 3:
+            return False
+
+        # 4) require that most values cluster around median
+        within_range = ((s >= median * 0.5) & (s <= median * 1.5)).mean()
+        if within_range < 0.6:
+            return False
+
+        return True
+
+    # ---------- CANDIDATE GENERATION ----------
+    def _candidates(self, x: float) -> list[float]:
+        """Generate plausible human-error corrections for a single value."""
+        cands = []
+
+        # 1) divide by 10 (e.g., 222 → 22.2)
+        cands.append(x / 10)
+
+        # 2) decrease the left-most digit by 1 (e.g., 222 → 122)
+        s = str(int(round(x)))
+        if len(s) > 1 and s.isdigit():
+            first = str(max(0, int(s[0]) - 1))
+            cands.append(float(first + s[1:]))
+
+        # 3) increase the left-most digit by 1 (in case the error went the other way)
+        if len(s) > 1 and s.isdigit():
+            first = str(int(s[0]) + 1)
+            cands.append(float(first + s[1:]))
+
+        # 4) handle repeated digits like 777 → 77.7
+        if len(s) >= 3 and len(set(s)) == 1:
+            cands.append(x / 10)
+            cands.append(float(s[:-1]))
+
+        return list(set(cands))
+
+    # ---------- CHOOSE BEST CANDIDATE ----------
+    def _pick_best(self, x: float, mean: float, cands: list[float]) -> float:
+        """
+        Pick the candidate closest to the column mean.
+        Apply temperature scaling to avoid over-correction.
+        """
+        if not cands:
+            return x
+
+        # distance to mean
+        dists = [abs(c - mean) for c in cands]
+        best = cands[int(np.argmin(dists))]
+
+        # if correction is too far from original, keep original
+        if abs(best - x) > abs(mean) * 2 * self.temperature:
+            return x
+        return best
+
+    # ---------- PUBLIC API ----------
+    def fit_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        """
+        Apply human-error correction column-wise to numeric columns.
+        Non-numeric columns are left unchanged.
+        Returns a corrected copy of the dataframe.
+        """
+        df = df.copy()
+
+        for col in df.columns:
+            if not pd.api.types.is_numeric_dtype(df[col]):
+                continue
+
+            s = df[col].astype(float)
+            if not self._data_ok_for_correction(s):
+                continue
+
+            mean = s.mean()
+            corrected = []
+
+            for x in s:
+                if pd.isna(x):
+                    corrected.append(np.nan)
+                    continue
+
+                # flag potential outlier: > 2*mean or < 0.5*mean
+                if x > 2 * mean or x < 0.5 * mean:
+                    cands = self._candidates(x)
+                    corrected.append(self._pick_best(x, mean, cands))
+                else:
+                    corrected.append(x)
+
+            df[col] = corrected
+
+        return df

devg_humanerror-0.1.0/devg_humanerror/correctors.py

@@ -0,0 +1,2 @@
+def example_function():
+    return "Correctors module is working"

devg_humanerror-0.1.0/devg_humanerror/detectors.py

@@ -0,0 +1,2 @@
+def check_all():
+    return "Detectors precheck OK"

devg_humanerror-0.1.0/devg_humanerror/diagnostics.py

@@ -0,0 +1,8 @@
+# devg_humanerror/diagnostics.py
+
+# --- Standalone function at top-level ---
+def generate_candidates(input_text):
+    """
+    Generate candidate fixes for the given input text.
+    """
+    return [f"Candidate fix for: {input_text}"]

devg_humanerror-0.1.0/devg_humanerror.egg-info/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: devg-humanerror
+Version: 0.1.0
+Summary: Automatic correction of human-entry errors in tabular data
+Author: Dev Ganjawalla
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Dynamic: license-file
+
+\# devg-humanerror
+
+
+
+A tiny Python library to rescue your datasets from human data-entry errors 😎  
+
+Created by Dev Ganjawalla because finger slips happen.
+
+
+
+\## Features
+
+\- Detect repeated digits like 777 → 77.7
+
+\- Leading-digit corrections like 222 → 122
+
+\- Prechecks for symmetry, moderate spread, unimodal clusters
+
+\- Temperature parameter to adjust aggressiveness
+
+
+
+\## Installation
+
+
+
+```bash
+
+pip install devg-humanerror
+
+
+

devg_humanerror-0.1.0/devg_humanerror.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE.txt
+README.md
+README.txt
+pyproject.toml
+devg_humanerror/__init__.py
+devg_humanerror/core.py
+devg_humanerror/correctors.py
+devg_humanerror/detectors.py
+devg_humanerror/diagnostics.py
+devg_humanerror.egg-info/PKG-INFO
+devg_humanerror.egg-info/SOURCES.txt
+devg_humanerror.egg-info/dependency_links.txt
+devg_humanerror.egg-info/top_level.txt
+tests/test_core.py
+tests/test_package.py

devg_humanerror-0.1.0/devg_humanerror.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

devg_humanerror-0.1.0/devg_humanerror.egg-info/top_level.txt

@@ -0,0 +1 @@
+devg_humanerror

devg_humanerror-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=42"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "devg-humanerror"                     
+version = "0.1.0"
+description = "Automatic correction of human-entry errors in tabular data"
+authors = [{name="Dev Ganjawalla"}]
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+dependencies = []

devg_humanerror-0.1.0/setup.cfg

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

devg_humanerror-0.1.0/tests/test_core.py

@@ -0,0 +1,12 @@
+from devg_humanerror import safe_corrector, prechecks, candidate_fixes
+
+# Example: call a simple function from safe_corrector
+print(safe_corrector.example_function())
+
+# Run a precheck
+print(prechecks.check_all())
+
+# Generate candidate fixes
+fixes = candidate_fixes.generate_candidates("some error input")
+print(fixes)
+

devg_humanerror-0.1.0/tests/test_package.py

@@ -0,0 +1,35 @@
+# tests/test_package.py
+
+import sys
+import os
+
+# Add parent folder to path so Python can find devg_humanerror
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+# Import the function after fixing path
+from devg_humanerror.diagnostics import generate_candidates
+
+# --- Test functions ---
+def test_core():
+    print("Core module is working")
+
+def test_correctors():
+    print("Correctors module is working")
+
+def test_detectors():
+    print("Detectors precheck OK")
+
+def test_diagnostics():
+    try:
+        result = generate_candidates("sample input")
+        print("Diagnostics module working, output:", result)
+    except AttributeError as e:
+        print("ERROR in diagnostics:", e)
+
+# --- Run all tests ---
+if __name__ == "__main__":
+    test_core()
+    test_correctors()
+    test_detectors()
+    test_diagnostics()
+    print("\n✅ All tests completed!")