minimindslab-env-file-diff 0.1.0__tar.gz

minimindslab_env_file_diff-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_env_file_diff-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: minimindslab-env-file-diff
+Version: 0.1.0
+Summary: Deterministically compare two .env-style files and report added, removed, changed, and ignored keys with stable ordering.
+Author: MiniMindsLab
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# MiniMindsLab Env File Diff
+
+Deterministically compare two `.env`-style files and report:
+
+- Added keys
+- Removed keys
+- Changed keys
+- Ignored lines (comments/blank/invalid)
+
+## Features
+
+- Stable ordering (sorted keys in output)
+- Whitespace-tolerant parsing
+- `#` comments and blank lines are ignored
+- Duplicate keys resolve by **last occurrence wins**
+- Pure Python standard library only
+
+## Installation
+
+```bash
+pip install minimindslab-env-file-diff
+```
+
+## CLI Usage
+
+```bash
+miniminds-env-diff path/to/old.env path/to/new.env
+```
+
+Example output:
+
+```text
+ADDED (1)
+  + NEW_KEY=new
+REMOVED (1)
+  - OLD_KEY=old
+CHANGED (1)
+  ~ SHARED_KEY: before -> after
+IGNORED
+  old.env: comments=1 blanks=1 invalid=0
+  new.env: comments=0 blanks=2 invalid=1
+```
+
+## Library Usage
+
+```python
+from minimindslab_env_file_diff import compare_env_files
+
+result = compare_env_files("old.env", "new.env")
+print(result["added"])
+print(result["removed"])
+print(result["changed"])
+```

minimindslab_env_file_diff-0.1.0/README.md

@@ -0,0 +1,53 @@
+# MiniMindsLab Env File Diff
+
+Deterministically compare two `.env`-style files and report:
+
+- Added keys
+- Removed keys
+- Changed keys
+- Ignored lines (comments/blank/invalid)
+
+## Features
+
+- Stable ordering (sorted keys in output)
+- Whitespace-tolerant parsing
+- `#` comments and blank lines are ignored
+- Duplicate keys resolve by **last occurrence wins**
+- Pure Python standard library only
+
+## Installation
+
+```bash
+pip install minimindslab-env-file-diff
+```
+
+## CLI Usage
+
+```bash
+miniminds-env-diff path/to/old.env path/to/new.env
+```
+
+Example output:
+
+```text
+ADDED (1)
+  + NEW_KEY=new
+REMOVED (1)
+  - OLD_KEY=old
+CHANGED (1)
+  ~ SHARED_KEY: before -> after
+IGNORED
+  old.env: comments=1 blanks=1 invalid=0
+  new.env: comments=0 blanks=2 invalid=1
+```
+
+## Library Usage
+
+```python
+from minimindslab_env_file_diff import compare_env_files
+
+result = compare_env_files("old.env", "new.env")
+print(result["added"])
+print(result["removed"])
+print(result["changed"])
+```

minimindslab_env_file_diff-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "minimindslab-env-file-diff"
+version = "0.1.0"
+description = "Deterministically compare two .env-style files and report added, removed, changed, and ignored keys with stable ordering."
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "MiniMindsLab" }]
+dependencies = []
+
+[project.scripts]
+miniminds-env-diff = "minimindslab_env_file_diff.__main__:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

minimindslab_env_file_diff-0.1.0/setup.cfg

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

minimindslab_env_file_diff-0.1.0/src/minimindslab_env_file_diff/__init__.py

@@ -0,0 +1,10 @@
+"""MiniMindsLab Env File Diff."""
+
+from .core import compare_env_files, compare_env_mappings, parse_env_file, render_report
+
+__all__ = [
+    "parse_env_file",
+    "compare_env_mappings",
+    "compare_env_files",
+    "render_report",
+]

minimindslab_env_file_diff-0.1.0/src/minimindslab_env_file_diff/__main__.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from .core import compare_env_files, render_report
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="miniminds-env-diff",
+        description="Deterministically compare two .env-style files.",
+    )
+    parser.add_argument("old_file")
+    parser.add_argument("new_file")
+    args = parser.parse_args(argv)
+
+    old_label = Path(args.old_file).name
+    new_label = Path(args.new_file).name
+
+    try:
+        diff = compare_env_files(args.old_file, args.new_file)
+    except FileNotFoundError as exc:
+        print(str(exc), file=sys.stderr)
+        return 2
+
+    print(render_report(diff, old_label, new_label))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

minimindslab_env_file_diff-0.1.0/src/minimindslab_env_file_diff/core.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Tuple
+
+
+@dataclass(frozen=True)
+class ParseStats:
+    comments: int
+    blanks: int
+    invalid: int
+
+
+def parse_env_file(path: str | Path) -> Tuple[Dict[str, str], ParseStats]:
+    p = Path(path)
+    if not p.exists() or not p.is_file():
+        raise FileNotFoundError(f"File not found: {p}")
+
+    mapping: Dict[str, str] = {}
+    comments = 0
+    blanks = 0
+    invalid = 0
+
+    with p.open("r", encoding="utf-8") as f:
+        for raw in f:
+            line = raw.strip()
+            if not line:
+                blanks += 1
+                continue
+            if line.startswith("#"):
+                comments += 1
+                continue
+            if "=" not in line:
+                invalid += 1
+                continue
+            key, value = line.split("=", 1)
+            key = key.strip()
+            value = value.strip()
+            if not key:
+                invalid += 1
+                continue
+            mapping[key] = value
+
+    return mapping, ParseStats(comments=comments, blanks=blanks, invalid=invalid)
+
+
+def compare_env_mappings(old: Dict[str, str], new: Dict[str, str]) -> dict:
+    old_keys = set(old)
+    new_keys = set(new)
+
+    added_keys = sorted(new_keys - old_keys)
+    removed_keys = sorted(old_keys - new_keys)
+    common = sorted(old_keys & new_keys)
+    changed_keys = [k for k in common if old[k] != new[k]]
+
+    return {
+        "added": {k: new[k] for k in added_keys},
+        "removed": {k: old[k] for k in removed_keys},
+        "changed": {k: {"old": old[k], "new": new[k]} for k in changed_keys},
+    }
+
+
+def compare_env_files(old_path: str | Path, new_path: str | Path) -> dict:
+    old_map, old_stats = parse_env_file(old_path)
+    new_map, new_stats = parse_env_file(new_path)
+    diff = compare_env_mappings(old_map, new_map)
+    diff["ignored"] = {
+        str(Path(old_path).name): {
+            "comments": old_stats.comments,
+            "blanks": old_stats.blanks,
+            "invalid": old_stats.invalid,
+        },
+        str(Path(new_path).name): {
+            "comments": new_stats.comments,
+            "blanks": new_stats.blanks,
+            "invalid": new_stats.invalid,
+        },
+    }
+    return diff
+
+
+def render_report(diff: dict, old_label: str, new_label: str) -> str:
+    lines: list[str] = []
+
+    added = diff["added"]
+    removed = diff["removed"]
+    changed = diff["changed"]
+
+    lines.append(f"ADDED ({len(added)})")
+    for k in sorted(added):
+        lines.append(f"  + {k}={added[k]}")
+
+    lines.append(f"REMOVED ({len(removed)})")
+    for k in sorted(removed):
+        lines.append(f"  - {k}={removed[k]}")
+
+    lines.append(f"CHANGED ({len(changed)})")
+    for k in sorted(changed):
+        lines.append(f"  ~ {k}: {changed[k]['old']} -> {changed[k]['new']}")
+
+    ignored = diff.get("ignored", {})
+    lines.append("IGNORED")
+    for label in (old_label, new_label):
+        stats = ignored.get(label, {"comments": 0, "blanks": 0, "invalid": 0})
+        lines.append(
+            f"  {label}: comments={stats['comments']} blanks={stats['blanks']} invalid={stats['invalid']}"
+        )
+
+    return "\n".join(lines)

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

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: minimindslab-env-file-diff
+Version: 0.1.0
+Summary: Deterministically compare two .env-style files and report added, removed, changed, and ignored keys with stable ordering.
+Author: MiniMindsLab
+License: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# MiniMindsLab Env File Diff
+
+Deterministically compare two `.env`-style files and report:
+
+- Added keys
+- Removed keys
+- Changed keys
+- Ignored lines (comments/blank/invalid)
+
+## Features
+
+- Stable ordering (sorted keys in output)
+- Whitespace-tolerant parsing
+- `#` comments and blank lines are ignored
+- Duplicate keys resolve by **last occurrence wins**
+- Pure Python standard library only
+
+## Installation
+
+```bash
+pip install minimindslab-env-file-diff
+```
+
+## CLI Usage
+
+```bash
+miniminds-env-diff path/to/old.env path/to/new.env
+```
+
+Example output:
+
+```text
+ADDED (1)
+  + NEW_KEY=new
+REMOVED (1)
+  - OLD_KEY=old
+CHANGED (1)
+  ~ SHARED_KEY: before -> after
+IGNORED
+  old.env: comments=1 blanks=1 invalid=0
+  new.env: comments=0 blanks=2 invalid=1
+```
+
+## Library Usage
+
+```python
+from minimindslab_env_file_diff import compare_env_files
+
+result = compare_env_files("old.env", "new.env")
+print(result["added"])
+print(result["removed"])
+print(result["changed"])
+```

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

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

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,2 @@
+[console_scripts]
+miniminds-env-diff = minimindslab_env_file_diff.__main__:main

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

@@ -0,0 +1 @@
+minimindslab_env_file_diff

minimindslab_env_file_diff-0.1.0/tests/test_env_diff.py

@@ -0,0 +1,72 @@
+import contextlib
+import io
+import tempfile
+import unittest
+from pathlib import Path
+
+from minimindslab_env_file_diff import __main__ as cli_main
+from minimindslab_env_file_diff.core import compare_env_files, parse_env_file
+
+
+class EnvDiffTests(unittest.TestCase):
+    def test_acceptance_sorted_added_removed_changed(self):
+        with tempfile.TemporaryDirectory() as td:
+            old_p = Path(td) / "old.env"
+            new_p = Path(td) / "new.env"
+            old_p.write_text("A=1\nB=2\nC=3\n", encoding="utf-8")
+            new_p.write_text("B=2\nC=30\nD=4\n", encoding="utf-8")
+
+            diff = compare_env_files(old_p, new_p)
+            self.assertEqual(list(diff["added"].keys()), ["D"])
+            self.assertEqual(list(diff["removed"].keys()), ["A"])
+            self.assertEqual(list(diff["changed"].keys()), ["C"])
+
+    def test_acceptance_ignore_comments_blanks_whitespace(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = Path(td) / "a.env"
+            p.write_text("\n  # c1\n  KEY = value  \nINVALID\n", encoding="utf-8")
+            mapping, stats = parse_env_file(p)
+            self.assertEqual(mapping, {"KEY": "value"})
+            self.assertEqual(stats.comments, 1)
+            self.assertEqual(stats.blanks, 1)
+            self.assertEqual(stats.invalid, 1)
+
+    def test_acceptance_duplicate_key_last_wins(self):
+        with tempfile.TemporaryDirectory() as td:
+            p = Path(td) / "dup.env"
+            p.write_text("X=1\nX=2\nX=3\n", encoding="utf-8")
+            mapping, _ = parse_env_file(p)
+            self.assertEqual(mapping["X"], "3")
+
+    def test_cli_stable_output_and_exit_zero(self):
+        with tempfile.TemporaryDirectory() as td:
+            old_p = Path(td) / "old.env"
+            new_p = Path(td) / "new.env"
+            old_p.write_text("A=1\n#x\n\n", encoding="utf-8")
+            new_p.write_text("A=2\nB=3\n", encoding="utf-8")
+
+            out1 = io.StringIO()
+            out2 = io.StringIO()
+
+            with contextlib.redirect_stdout(out1):
+                code1 = cli_main.main([str(old_p), str(new_p)])
+            with contextlib.redirect_stdout(out2):
+                code2 = cli_main.main([str(old_p), str(new_p)])
+
+            self.assertEqual(code1, 0)
+            self.assertEqual(code2, 0)
+            self.assertEqual(out1.getvalue(), out2.getvalue())
+            self.assertIn("ADDED (1)", out1.getvalue())
+            self.assertIn("CHANGED (1)", out1.getvalue())
+
+    def test_negative_missing_file(self):
+        with tempfile.TemporaryDirectory() as td:
+            old_p = Path(td) / "missing.env"
+            new_p = Path(td) / "new.env"
+            new_p.write_text("A=1\n", encoding="utf-8")
+            with self.assertRaises(FileNotFoundError):
+                compare_env_files(old_p, new_p)
+
+
+if __name__ == "__main__":
+    unittest.main()