cgh-codegen 0.1.0__tar.gz → 0.1.1__tar.gz

{cgh_codegen-0.1.0 → cgh_codegen-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgh-codegen
-Version: 0.1.0
+Version: 0.1.1
 Summary: Pattern-matched code generation for cgh: a cheap model writes boilerplate that mirrors a reference file cgh picks from the graph
 Author-email: Joy Ndjama <joy.ndjama@altikva.com>
 License-Expression: MIT

{cgh_codegen-0.1.0 → cgh_codegen-0.1.1}/cgh_codegen/flow.py

@@ -191,6 +191,20 @@ def run_generation(
                     "to regenerate it from scratch."
                 )
 
+    # The checks above run before generation, which can take minutes. Every
+    # write below also checks, at the moment of writing, that the target still
+    # holds what this run expects: nothing for a new file, the content read
+    # above for force or extend, then whatever this run last wrote. A file
+    # created or edited by anyone else in between is left as is and the call
+    # fails, instead of being overwritten without a word.
+    expected: str | None = None
+    if tgt is not None and tgt.exists():
+        expected = _sha(
+            existing_text
+            if existing_text is not None
+            else tgt.read_text(encoding="utf-8", errors="replace")
+        )
+
     do_verify = bool(verify) and not to_stdout
     prior: tuple[str, str] | None = None
     verified: bool | None = None
@@ -224,12 +238,16 @@ def run_generation(
             body = _append_into(existing_text, code)
         else:
             body = code if code.endswith("\n") else code + "\n"
-        tgt.parent.mkdir(parents=True, exist_ok=True)
-        tgt.write_text(body, encoding="utf-8")
+        _write_expected(tgt, body, expected, target)
+        expected = _sha(body)
         written = True
         if not do_verify:
             break
         ok, output = _run_verify(root, verify)  # type: ignore[arg-type]
+        # The check belongs to this run and may rewrite the file itself (a
+        # formatter with --fix), so what it leaves is what the next attempt
+        # expects to replace.
+        expected = _sha(tgt.read_text(encoding="utf-8", errors="replace"))
         verified = ok
         if ok:
             break
@@ -241,7 +259,7 @@ def run_generation(
     # unparsable. So put the original back and report the failure instead.
     rolled_back = False
     if extend and written and do_verify and not verified and existing_text is not None:
-        tgt.write_text(existing_text, encoding="utf-8")  # type: ignore[union-attr]
+        _write_expected(tgt, existing_text, expected, target)  # type: ignore[arg-type]
         written = False
         rolled_back = True
 
@@ -408,6 +426,40 @@ def _sha(text: str) -> str:
     return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
 
+def _write_expected(tgt: Path, body: str, expected: str | None, target: str) -> None:
+    """Write ``body`` only if the target still holds what this run expects.
+
+    ``expected`` is the sha of the content that should be on disk, or None when
+    the file must not exist yet. A new file is created exclusively, so one that
+    appeared during generation fails the open instead of being truncated. For
+    an existing file the content is compared just before writing; the window
+    left between that read and the write is a few syscalls, against minutes of
+    generation before. On a mismatch nothing is written and the caller is told,
+    so another writer's work is never lost."""
+    tgt.parent.mkdir(parents=True, exist_ok=True)
+    if expected is None:
+        try:
+            with open(tgt, "x", encoding="utf-8") as fh:
+                fh.write(body)
+        except FileExistsError:
+            raise CodegenError(
+                f"target {target} appeared while codegen was generating it; it "
+                "was left as is and nothing was written. Read it before "
+                "generating again."
+            ) from None
+        return
+    try:
+        current: str | None = _sha(tgt.read_text(encoding="utf-8", errors="replace"))
+    except FileNotFoundError:
+        current = None
+    if current != expected:
+        raise CodegenError(
+            f"target {target} changed while codegen was generating; it was left "
+            "as is and nothing was written, so those changes are not lost."
+        )
+    tgt.write_text(body, encoding="utf-8")
+
+
 def _provenance_path(root: Path) -> Path:
     return root / ".codegraph" / "codegen" / "provenance.json"
 

{cgh_codegen-0.1.0 → cgh_codegen-0.1.1}/cgh_codegen.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cgh-codegen
-Version: 0.1.0
+Version: 0.1.1
 Summary: Pattern-matched code generation for cgh: a cheap model writes boilerplate that mirrors a reference file cgh picks from the graph
 Author-email: Joy Ndjama <joy.ndjama@altikva.com>
 License-Expression: MIT

{cgh_codegen-0.1.0 → cgh_codegen-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cgh-codegen"
-version = "0.1.0"
+version = "0.1.1"
 description = "Pattern-matched code generation for cgh: a cheap model writes boilerplate that mirrors a reference file cgh picks from the graph"
 readme = "README.md"
 requires-python = ">=3.11"

{cgh_codegen-0.1.0 → cgh_codegen-0.1.1}/tests/test_flow.py

@@ -12,6 +12,8 @@
 
 from __future__ import annotations
 
+import sys
+
 import pytest
 
 pytest.importorskip("cgh_codegen")
@@ -476,5 +478,109 @@ def test_generated_python_is_ruff_polished(tmp_path):
     assert all(line == line.rstrip() for line in content.splitlines())
 
 
+class _WriterDuringGeneration:
+    """A backend that, while it "thinks", lets someone else write the target:
+    a hand edit, or another codegen call. Generation takes minutes in real use,
+    and the flow used to check the target only before it."""
+
+    is_local = True
+    name = "fake"
+
+    def __init__(self, target, text: str, reply: str) -> None:
+        self._target, self._text, self._reply = target, text, reply
+
+    def generate(self, system: str, user: str) -> tuple[str, float]:
+        self._target.write_text(self._text, encoding="utf-8")
+        return self._reply, 0.0
+
+
+class TestWritesDuringGeneration:
+    def test_a_file_created_meanwhile_is_not_overwritten(self, tmp_path):
+        root = _repo(tmp_path)
+        target = root / "src" / "user_service.py"
+        backend = _WriterDuringGeneration(
+            target, "# written by hand\n", "```python\nx = 1\n```"
+        )
+        with pytest.raises(CodegenError, match="appeared while codegen"):
+            run_generation(
+                root,
+                "spec",
+                "src/user_service.py",
+                "src/order_service.py",
+                config={},
+                backend=backend,
+            )
+        assert target.read_text(encoding="utf-8") == "# written by hand\n"
+
+    def test_force_keeps_an_edit_made_meanwhile(self, tmp_path):
+        root = _repo(tmp_path)
+        target = root / "src" / "user_service.py"
+        run_generation(
+            root,
+            "spec",
+            "src/user_service.py",
+            "src/order_service.py",
+            config={},
+            backend=FakeBackend("```python\nx = 1\n```"),
+        )
+        backend = _WriterDuringGeneration(
+            target, "x = 1\n# edited meanwhile\n", "```python\nx = 2\n```"
+        )
+        with pytest.raises(CodegenError, match="changed while codegen"):
+            run_generation(
+                root,
+                "spec",
+                "src/user_service.py",
+                "src/order_service.py",
+                config={},
+                backend=backend,
+                force=True,
+            )
+        assert "# edited meanwhile" in target.read_text(encoding="utf-8")
+
+    def test_extend_keeps_an_edit_made_meanwhile(self, tmp_path):
+        root = _repo(tmp_path)
+        target = root / "src" / "existing.py"
+        target.write_text("# original\n", encoding="utf-8")
+        backend = _WriterDuringGeneration(
+            target, "# original\n# edited meanwhile\n", "```python\nx = 1\n```"
+        )
+        with pytest.raises(CodegenError, match="changed while codegen"):
+            run_generation(
+                root,
+                "spec",
+                "src/existing.py",
+                None,
+                config={},
+                backend=backend,
+                extend=True,
+            )
+        assert target.read_text(encoding="utf-8") == "# original\n# edited meanwhile\n"
+
+    def test_a_verify_that_rewrites_the_file_does_not_block_the_retry(self, tmp_path):
+        # The check is part of this run; a formatter that rewrites the file in
+        # place must not be mistaken for another writer on the next attempt.
+        root = _repo(tmp_path)
+        backend = SequenceBackend(
+            ["```python\nx = 1  # bad\n```", "```python\nx = 1  # GOOD\n```"]
+        )
+        out = run_generation(
+            root,
+            "spec",
+            "src/x.py",
+            "src/order_service.py",
+            config={},
+            backend=backend,
+            # argv, no shell: append to the file, then pass only once it says GOOD
+            verify=(
+                f"{sys.executable} -c \"import pathlib, sys; p = pathlib.Path('src/x.py'); "
+                "t = p.read_text(); p.write_text(t + '# touched by the check\\n'); "
+                "sys.exit(0 if 'GOOD' in t else 1)\""
+            ),
+            max_attempts=3,
+        )
+        assert out["verified"] is True and out["attempts"] == 2
+
+
 if __name__ == "__main__":  # pragma: no cover
     pytest.main([__file__, "-q"])