minimindslab-csv-normalize 0.1.0__tar.gz

minimindslab_csv_normalize-0.1.0/LICENSE

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

minimindslab_csv_normalize-0.1.0/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: minimindslab-csv-normalize
+Version: 0.1.0
+Summary: Normalize small CSV text into stable, comparison-friendly output with controllable header ordering, trimming, and line endings.
+Author: MiniMindsLab
+License: MIT
+Keywords: csv,normalize,deterministic,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# MiniMindsLab CSV Normalize
+
+Deterministically normalize small CSV text for stable diffs, tests, and reviews.
+
+## Features
+
+- Trims surrounding whitespace in headers and cell values.
+- Normalizes mixed line endings to `\n`.
+- Optional stable header sorting.
+- Deterministic output for identical logical input.
+- Library API and CLI.
+
+## Library Usage
+
+```python
+from minimindslab_csv_normalize import normalize_csv
+
+raw = " Name , Age \r\n Alice , 30 \r\n"
+out = normalize_csv(raw)
+print(out)
+# Age,Name\n30,Alice\n
+# Keep original header order
+out2 = normalize_csv(raw, sort_headers=False)
+print(out2)
+# Name,Age\nAlice,30\n
+```
+
+## CLI Usage
+
+From stdin:
+
+```bash
+echo " Name , Age \r\n Alice , 30 " | miniminds-csv-normalize
+```
+
+From file:
+
+```bash
+miniminds-csv-normalize --input sample.csv
+```
+
+Disable header sorting:
+
+```bash
+miniminds-csv-normalize --no-sort-headers --input sample.csv
+```

minimindslab_csv_normalize-0.1.0/README.md

@@ -0,0 +1,46 @@
+# MiniMindsLab CSV Normalize
+
+Deterministically normalize small CSV text for stable diffs, tests, and reviews.
+
+## Features
+
+- Trims surrounding whitespace in headers and cell values.
+- Normalizes mixed line endings to `\n`.
+- Optional stable header sorting.
+- Deterministic output for identical logical input.
+- Library API and CLI.
+
+## Library Usage
+
+```python
+from minimindslab_csv_normalize import normalize_csv
+
+raw = " Name , Age \r\n Alice , 30 \r\n"
+out = normalize_csv(raw)
+print(out)
+# Age,Name\n30,Alice\n
+# Keep original header order
+out2 = normalize_csv(raw, sort_headers=False)
+print(out2)
+# Name,Age\nAlice,30\n
+```
+
+## CLI Usage
+
+From stdin:
+
+```bash
+echo " Name , Age \r\n Alice , 30 " | miniminds-csv-normalize
+```
+
+From file:
+
+```bash
+miniminds-csv-normalize --input sample.csv
+```
+
+Disable header sorting:
+
+```bash
+miniminds-csv-normalize --no-sort-headers --input sample.csv
+```

minimindslab_csv_normalize-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "minimindslab-csv-normalize"
+version = "0.1.0"
+description = "Normalize small CSV text into stable, comparison-friendly output with controllable header ordering, trimming, and line endings."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "MiniMindsLab" }]
+dependencies = []
+keywords = ["csv", "normalize", "deterministic", "cli"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Topic :: Software Development :: Testing",
+  "Topic :: Text Processing"
+]
+
+[project.scripts]
+miniminds-csv-normalize = "minimindslab_csv_normalize.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

minimindslab_csv_normalize-0.1.0/setup.cfg

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

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize/__init__.py

@@ -0,0 +1,6 @@
+"""MiniMindsLab CSV Normalize."""
+
+from .core import normalize_csv
+
+__all__ = ["normalize_csv"]
+__version__ = "0.1.0"

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize/__main__.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import argparse
+import sys
+
+from .core import normalize_csv
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="Normalize small CSV text deterministically.")
+    parser.add_argument("--input", "-i", help="Path to input CSV file. If omitted, read from stdin.")
+    parser.add_argument("--no-sort-headers", action="store_true", help="Preserve original header order.")
+    parser.add_argument("--newline", choices=["lf", "crlf"], default="lf", help="Output newline style.")
+    return parser
+
+
+def main() -> int:
+    parser = build_parser()
+    args = parser.parse_args()
+
+    if args.input:
+        with open(args.input, "r", encoding="utf-8", newline="") as f:
+            text = f.read()
+    else:
+        text = sys.stdin.read()
+
+    nl = "\n" if args.newline == "lf" else "\r\n"
+    result = normalize_csv(text, sort_headers=not args.no_sort_headers, newline=nl)
+    sys.stdout.write(result)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize/core.py

@@ -0,0 +1,60 @@
+"""Core CSV normalization logic."""
+
+from __future__ import annotations
+
+import csv
+import io
+from typing import List
+
+
+def _normalize_newlines(text: str) -> str:
+    return text.replace("\r\n", "\n").replace("\r", "\n")
+
+
+def normalize_csv(text: str, *, sort_headers: bool = True, newline: str = "\n") -> str:
+    """Normalize CSV text into stable output.
+
+    - Normalizes line endings in input.
+    - Trims leading/trailing whitespace for all cells.
+    - Optionally sorts headers alphabetically for deterministic column order.
+    - Emits output with a consistent newline and trailing newline when non-empty.
+    """
+    if not isinstance(text, str):
+        raise TypeError("text must be a str")
+    if newline not in {"\n", "\r\n"}:
+        raise ValueError("newline must be '\\n' or '\\r\\n'")
+
+    src = _normalize_newlines(text)
+    if src.strip() == "":
+        return ""
+
+    reader = csv.reader(io.StringIO(src))
+    rows: List[List[str]] = [[cell.strip() for cell in row] for row in reader]
+    if not rows:
+        return ""
+
+    header = rows[0]
+    data = rows[1:]
+
+    if sort_headers:
+        indices = sorted(range(len(header)), key=lambda i: (header[i], i))
+        header = [header[i] for i in indices]
+
+        def reorder(row: List[str]) -> List[str]:
+            padded = row + [""] * (len(indices) - len(row))
+            return [padded[i] if i < len(padded) else "" for i in indices]
+
+        data = [reorder(r) for r in data]
+    else:
+        data = [r + [""] * (len(header) - len(r)) if len(r) < len(header) else r[: len(header)] for r in data]
+
+    output = io.StringIO()
+    writer = csv.writer(output, lineterminator="\n")
+    writer.writerow(header)
+    for row in data:
+        writer.writerow(row)
+
+    rendered = output.getvalue()
+    if newline != "\n":
+        rendered = rendered.replace("\n", newline)
+    return rendered

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize.egg-info/PKG-INFO

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: minimindslab-csv-normalize
+Version: 0.1.0
+Summary: Normalize small CSV text into stable, comparison-friendly output with controllable header ordering, trimming, and line endings.
+Author: MiniMindsLab
+License: MIT
+Keywords: csv,normalize,deterministic,cli
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Text Processing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# MiniMindsLab CSV Normalize
+
+Deterministically normalize small CSV text for stable diffs, tests, and reviews.
+
+## Features
+
+- Trims surrounding whitespace in headers and cell values.
+- Normalizes mixed line endings to `\n`.
+- Optional stable header sorting.
+- Deterministic output for identical logical input.
+- Library API and CLI.
+
+## Library Usage
+
+```python
+from minimindslab_csv_normalize import normalize_csv
+
+raw = " Name , Age \r\n Alice , 30 \r\n"
+out = normalize_csv(raw)
+print(out)
+# Age,Name\n30,Alice\n
+# Keep original header order
+out2 = normalize_csv(raw, sort_headers=False)
+print(out2)
+# Name,Age\nAlice,30\n
+```
+
+## CLI Usage
+
+From stdin:
+
+```bash
+echo " Name , Age \r\n Alice , 30 " | miniminds-csv-normalize
+```
+
+From file:
+
+```bash
+miniminds-csv-normalize --input sample.csv
+```
+
+Disable header sorting:
+
+```bash
+miniminds-csv-normalize --no-sort-headers --input sample.csv
+```

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/minimindslab_csv_normalize/__init__.py
+src/minimindslab_csv_normalize/__main__.py
+src/minimindslab_csv_normalize/core.py
+src/minimindslab_csv_normalize.egg-info/PKG-INFO
+src/minimindslab_csv_normalize.egg-info/SOURCES.txt
+src/minimindslab_csv_normalize.egg-info/dependency_links.txt
+src/minimindslab_csv_normalize.egg-info/entry_points.txt
+src/minimindslab_csv_normalize.egg-info/top_level.txt
+tests/test_normalize.py

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+miniminds-csv-normalize = minimindslab_csv_normalize.__main__:main

minimindslab_csv_normalize-0.1.0/src/minimindslab_csv_normalize.egg-info/top_level.txt

@@ -0,0 +1 @@
+minimindslab_csv_normalize

minimindslab_csv_normalize-0.1.0/tests/test_normalize.py

@@ -0,0 +1,75 @@
+import importlib
+import os
+import tempfile
+import unittest
+
+from minimindslab_csv_normalize import normalize_csv
+
+
+class TestNormalizeCSV(unittest.TestCase):
+    def test_trim_and_stable_form(self):
+        text = " Name , Age \n Alice , 30 \n"
+        got = normalize_csv(text)
+        self.assertEqual(got, "Age,Name\n30,Alice\n")
+
+    def test_mixed_newlines_deterministic(self):
+        text = "b,a\r\n2,1\r3,4\n"
+        got = normalize_csv(text)
+        self.assertEqual(got, "a,b\n1,2\n4,3\n")
+
+    def test_idempotent(self):
+        text = " z , y \n 1 , 2 \n"
+        a = normalize_csv(text)
+        b = normalize_csv(text)
+        self.assertEqual(a, b)
+
+    def test_negative_newline_option(self):
+        with self.assertRaises(ValueError):
+            normalize_csv("a,b\n1,2\n", newline="x")
+
+    def test_negative_type(self):
+        with self.assertRaises(TypeError):
+            normalize_csv(None)  # type: ignore[arg-type]
+
+
+class TestCLI(unittest.TestCase):
+    def _run_main(self, args, input_text=None):
+        old_argv = os.sys.argv
+        old_stdin = os.sys.stdin
+        old_stdout = os.sys.stdout
+        try:
+            mod = importlib.import_module("minimindslab_csv_normalize.__main__")
+            import io
+
+            os.sys.argv = ["miniminds-csv-normalize", *args]
+            os.sys.stdin = io.StringIO(input_text if input_text is not None else "")
+            captured = io.StringIO()
+            os.sys.stdout = captured
+            code = mod.main()
+            return code, captured.getvalue()
+        finally:
+            os.sys.argv = old_argv
+            os.sys.stdin = old_stdin
+            os.sys.stdout = old_stdout
+
+    def test_cli_stdin_matches_library(self):
+        text = " Name , Age \r\n Alice , 30 \n"
+        code, out = self._run_main([], input_text=text)
+        self.assertEqual(code, 0)
+        self.assertEqual(out, normalize_csv(text))
+
+    def test_cli_file_matches_library(self):
+        text = "b,a\n2,1\n"
+        with tempfile.NamedTemporaryFile("w", encoding="utf-8", delete=False) as tmp:
+            tmp.write(text)
+            path = tmp.name
+        try:
+            code, out = self._run_main(["--input", path])
+            self.assertEqual(code, 0)
+            self.assertEqual(out, normalize_csv(text))
+        finally:
+            os.unlink(path)
+
+
+if __name__ == "__main__":
+    unittest.main()