apply-patch-py 0.1.0__tar.gz

apply_patch_py-0.1.0/.github/workflows/lint.yml

@@ -0,0 +1,29 @@
+name: Linting
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.13
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run linter
+        shell: bash
+        run: uv run -- make lint

apply_patch_py-0.1.0/.github/workflows/test.yml

@@ -0,0 +1,29 @@
+name: Unit Testing
+
+on:
+  push:
+    branches: ["master"]
+  pull_request:
+    branches: ["master"]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+
+      - name: Set up Python
+        run: uv python install 3.13
+
+      - name: Install dependencies
+        run: uv sync
+
+      - name: Run tests
+        shell: bash
+        run: uv run -- make test

apply_patch_py-0.1.0/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.idea
+apply-patch-rust

apply_patch_py-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

apply_patch_py-0.1.0/LICENSE

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

apply_patch_py-0.1.0/Makefile

@@ -0,0 +1,48 @@
+.PHONY: init install format lint test build publish publish-test verify-testpypi clean
+
+PYTHON ?= uv run
+
+DIST_DIR := dist
+
+init:
+	@command -v uv >/dev/null 2>&1 || { echo >&2 "Error: uv is not installed."; exit 1; }
+	@command -v python >/dev/null 2>&1 || { echo >&2 "Error: python is not installed."; exit 1; }
+
+install: init
+	@uv sync
+
+format: init
+	@$(PYTHON) ruff check src tests --fix
+	@$(PYTHON) black src tests
+
+lint: init
+	@$(PYTHON) ruff check src tests
+	@$(PYTHON) black --check src tests
+	@$(PYTHON) mypy src
+
+test: init
+	@$(PYTHON) pytest
+
+# Preferred build (uv)
+build: init
+	@rm -rf $(DIST_DIR)
+	@uv build
+	@ls -la $(DIST_DIR)
+
+# Publish to PyPI (requires UV_PUBLISH_TOKEN)
+publish: build
+	@test -n "$$UV_PUBLISH_TOKEN" || { echo >&2 "Error: UV_PUBLISH_TOKEN is not set"; exit 1; }
+	@uv publish --token "$$UV_PUBLISH_TOKEN"
+
+# Publish to TestPyPI (requires UV_PUBLISH_TOKEN)
+publish-test: build
+	@test -n "$$UV_PUBLISH_TOKEN" || { echo >&2 "Error: UV_PUBLISH_TOKEN is not set"; exit 1; }
+	@uv publish --token "$$UV_PUBLISH_TOKEN" --publish-url https://test.pypi.org/legacy/
+
+# Verify install from TestPyPI (assumes publish-test was run)
+verify-testpypi:
+	@uv run --index-url https://test.pypi.org/simple --extra-index-url https://pypi.org/simple \
+		--with apply-patch-py --no-project -- python -c "import apply_patch_py"
+
+clean:
+	@rm -rf $(DIST_DIR) .pytest_cache .ruff_cache .mypy_cache

apply_patch_py-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: apply-patch-py
+Version: 0.1.0
+Summary: A python port of codex apply patch
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: aiofiles>=24.1.0

apply_patch_py-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[project]
+name = "apply-patch-py"
+version = "0.1.0"
+description = "A python port of codex apply patch"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "aiofiles>=24.1.0",
+]
+
+[project.scripts]
+apply-patch-py = "apply_patch_py:main"
+
+[dependency-groups]
+dev = [
+    "pydantic-ai>=1.44.0",
+    "pytest>=7.4.3,<8.0.0",
+    "pytest-asyncio>=0.23.8",
+    "black>=25.12.0",
+    "mypy<2.0.0,>=1.8.0",
+    "ruff<1.0.0,>=0.2.2",
+    "build>=1.0.0",
+    "twine>=5.0.0",
+    "types-aiofiles>=25.1.0.20251011",
+]
+
+[tool.uv]
+default-groups = ["dev"]
+
+[tool.ruff]
+exclude = [
+    "tests/integration/fixture/dirty_script.py",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/apply_patch_py"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+markers = [
+    "integration: integration test that requires external LLM provider configuration",
+]

apply_patch_py-0.1.0/src/apply_patch_py/__init__.py

@@ -0,0 +1,12 @@
+from pathlib import Path
+
+from .applier import PatchApplier
+from .cli import main
+from .models import AffectedPaths
+
+
+async def apply_patch(patch_text: str, workdir: Path = Path(".")) -> AffectedPaths:
+    return await PatchApplier.apply(patch_text, workdir)
+
+
+__all__ = ["apply_patch", "AffectedPaths", "main"]

apply_patch_py-0.1.0/src/apply_patch_py/applier.py

@@ -0,0 +1,239 @@
+import os
+import aiofiles
+from pathlib import Path
+from typing import List
+from .models import (
+    Hunk,
+    AddFile,
+    DeleteFile,
+    UpdateFile,
+    UpdateFileChunk,
+    AffectedPaths,
+)
+from .parser import PatchParser
+from .search import ContentSearcher
+
+
+class PatchApplier:
+    @classmethod
+    async def apply(cls, patch_text: str, workdir: Path = Path(".")) -> AffectedPaths:
+        try:
+            patch = PatchParser.parse(patch_text)
+        except ValueError as e:
+            raise RuntimeError(str(e)) from e
+
+        if not patch.hunks:
+            raise RuntimeError("No files were modified.")
+
+        affected = AffectedPaths()
+
+        for hunk in patch.hunks:
+            await cls._apply_hunk(hunk, workdir, affected)
+
+        return affected
+
+    @classmethod
+    async def _apply_hunk(cls, hunk: Hunk, workdir: Path, affected: AffectedPaths):
+        workdir = workdir.resolve()
+        path = workdir / hunk.path
+
+        if isinstance(hunk, AddFile):
+            if path.parent != workdir:
+                path.parent.mkdir(parents=True, exist_ok=True)
+
+            async with aiofiles.open(path, "w", encoding="utf-8") as f:
+                await f.write(hunk.content)
+            affected.added.append(hunk.path)
+
+        elif isinstance(hunk, DeleteFile):
+            try:
+                os.remove(path)
+            except OSError as e:
+                raise RuntimeError(f"Failed to delete file {hunk.path}") from e
+
+            affected.deleted.append(hunk.path)
+
+        elif isinstance(hunk, UpdateFile):
+            try:
+                async with aiofiles.open(path, "r", encoding="utf-8") as f:
+                    content = await f.read()
+            except FileNotFoundError as e:
+                raise RuntimeError(
+                    f"Failed to read file to update {hunk.path}: No such file or directory (os error 2)"
+                ) from e
+
+            original_lines = content.split("\n")
+            if original_lines and original_lines[-1] == "":
+                original_lines.pop()
+
+            new_lines = cls._apply_chunks(original_lines, hunk.chunks, hunk.path)
+
+            if not new_lines or new_lines[-1] != "":
+                new_lines.append("")
+            new_content = "\n".join(new_lines)
+
+            if hunk.move_to:
+                dest = workdir / hunk.move_to
+                if dest.parent != workdir:
+                    dest.parent.mkdir(parents=True, exist_ok=True)
+
+                async with aiofiles.open(dest, "w", encoding="utf-8") as f:
+                    await f.write(new_content)
+
+                try:
+                    os.remove(path)
+                except OSError as e:
+                    raise RuntimeError(f"Failed to remove original {hunk.path}") from e
+
+                affected.modified.append(hunk.move_to)
+            else:
+                async with aiofiles.open(path, "w", encoding="utf-8") as f:
+                    await f.write(new_content)
+                affected.modified.append(hunk.path)
+
+    @classmethod
+    def _apply_chunks(
+        cls, original_lines: List[str], chunks: List[UpdateFileChunk], path: Path
+    ) -> List[str]:
+        current_lines = list(original_lines)
+        line_index = 0
+
+        if not chunks:
+            raise RuntimeError(
+                f"Invalid patch: Update file hunk for path '{path}' is empty"
+            )
+
+        for chunk in chunks:
+            if chunk.change_context:
+                found_idx = ContentSearcher.find_sequence(
+                    current_lines,
+                    [chunk.change_context],
+                    line_index,
+                    False,
+                )
+                if found_idx is None:
+                    raise RuntimeError(
+                        f"Failed to find context '{chunk.change_context}' in {path}"
+                    )
+                line_index = found_idx + 1
+
+            if not chunk.old_lines:
+                insertion_idx = len(current_lines)
+                if current_lines and current_lines[-1] == "":
+                    insertion_idx -= 1
+                current_lines[insertion_idx:insertion_idx] = chunk.new_lines
+                line_index = insertion_idx + len(chunk.new_lines)
+                continue
+
+            pattern: List[str] = list(chunk.old_lines)
+            new_block: List[str] = list(chunk.new_lines)
+
+            found_idx = ContentSearcher.find_sequence(
+                current_lines,
+                pattern,
+                line_index,
+                chunk.is_end_of_file,
+            )
+
+            if found_idx is None and pattern and pattern[-1] == "":
+                pattern = pattern[:-1]
+                if new_block and new_block[-1] == "":
+                    new_block = new_block[:-1]
+
+                found_idx = ContentSearcher.find_sequence(
+                    current_lines,
+                    pattern,
+                    line_index,
+                    chunk.is_end_of_file,
+                )
+
+            if found_idx is None and line_index > 0:
+                found_idx = ContentSearcher.find_sequence(
+                    current_lines,
+                    pattern,
+                    0,
+                    chunk.is_end_of_file,
+                )
+
+            if found_idx is None:
+                found_idx = cls._fallback_find_lines_independently(
+                    current_lines=current_lines,
+                    pattern=pattern,
+                    start_idx=line_index,
+                    is_end_of_file=chunk.is_end_of_file,
+                )
+
+            if found_idx is None:
+                raise RuntimeError(
+                    f"Failed to find expected lines in {path}:\n"
+                    + "\n".join(chunk.old_lines)
+                )
+
+            match_len = len(pattern)
+            current_lines[found_idx : found_idx + match_len] = new_block
+            line_index = found_idx + len(new_block)
+
+        return current_lines
+
+    @classmethod
+    def _fallback_find_lines_independently(
+        cls,
+        *,
+        current_lines: List[str],
+        pattern: List[str],
+        start_idx: int,
+        is_end_of_file: bool,
+    ) -> int | None:
+        """Fallback matcher for imperfect LLM hunks.
+
+        Strict matching is attempted first. If it fails, we try to locate the edit
+        position using a couple of distinctive "anchor" lines from the old block.
+
+        To reduce the chance of patching the wrong location, we only accept anchors
+        that are unique in the file.
+        """
+
+        candidates: List[str] = [p for p in pattern if p.strip()]
+        if not candidates:
+            return None
+
+        anchors = candidates[:2]
+        if not anchors:
+            return None
+
+        anchor_matches: List[int] = []
+        for anchor in anchors:
+            if not cls._is_unique_line(current_lines, anchor):
+                return None
+
+            idx = ContentSearcher.find_sequence(
+                current_lines, [anchor], start_idx, is_end_of_file
+            )
+            if idx is None and start_idx > 0:
+                idx = ContentSearcher.find_sequence(
+                    current_lines, [anchor], 0, is_end_of_file
+                )
+            if idx is None:
+                return None
+            anchor_matches.append(idx)
+
+        if len(anchor_matches) >= 2 and anchor_matches[1] < anchor_matches[0]:
+            return None
+
+        return min(anchor_matches)
+
+    @staticmethod
+    def _is_unique_line(lines: List[str], line: str) -> bool:
+        """Return True if 'line' occurs exactly once in 'lines'.
+
+        We use strict equality; if normalization is needed, it should be applied at
+        the search layer.
+        """
+
+        count = 0
+        for candidate in lines:
+            if candidate == line:
+                count += 1
+                if count > 1:
+                    return False
+        return count == 1

apply_patch_py-0.1.0/src/apply_patch_py/cli.py

@@ -0,0 +1,50 @@
+import argparse
+import sys
+import asyncio
+from pathlib import Path
+from .applier import PatchApplier
+
+
+async def run_apply_patch(patch_text: str) -> int:
+    try:
+        affected = await PatchApplier.apply(patch_text, Path("."))
+        print("Success. Updated the following files:")
+        for path in affected.added:
+            print(f"A {path}")
+        for path in affected.modified:
+            print(f"M {path}")
+        for path in affected.deleted:
+            print(f"D {path}")
+        return 0
+    except Exception as e:
+        print(f"{e}", file=sys.stderr)
+        return 1
+    except BaseException as e:
+        # Catch-all for non-Exception errors (excluding SystemExit which is handled by caller/Python)
+        if isinstance(e, SystemExit):
+            raise
+        print(f"{e}", file=sys.stderr)
+        return 1
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Apply a patch to files.")
+    parser.add_argument(
+        "patch", nargs="?", help="The patch content. If omitted, reads from stdin."
+    )
+
+    args = parser.parse_args()
+
+    if args.patch:
+        patch_text = args.patch
+    else:
+        if sys.stdin.isatty():
+            parser.print_help()
+            sys.exit(2)
+        patch_text = sys.stdin.read()
+
+    try:
+        sys.exit(asyncio.run(run_apply_patch(patch_text)))
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        sys.exit(1)

apply_patch_py-0.1.0/src/apply_patch_py/constants.py

@@ -0,0 +1,36 @@
+PATCH_FORMAT_TOOL_INSTRUCTIONS = "Use this tool to edit files by applying patches. This is a FREEFORM tool, so do not wrap the patch in JSON. Your patch language is a stripped‑down, file‑oriented diff format designed to be easy to parse and safe to apply. You can think of it as a high‑level envelope"
+
+
+PATCH_FORMAT_INSTRUCTIONS = """
+*** Begin Patch
+[ one or more file sections ]
+*** End Patch
+
+Within that envelope, you get a sequence of file operations.
+You MUST include a header to specify the action you are taking.
+Each operation starts with one of three headers:
+
+*** Add File: <path> - create a new file. Every following line is a + line (the initial contents).
+*** Delete File: <path> - remove an existing file. Nothing follows.
+*** Update File: <path> - patch an existing file in place (optionally with a rename).
+
+Example patch:
+
+```
+*** Begin Patch
+*** Add File: hello.txt
++Hello world
+*** Update File: src/app.py
+*** Move to: src/main.py
+@@ def greet():
+-print("Hi")
++print("Hello, world!")
+*** Delete File: obsolete.txt
+*** End Patch
+```
+
+It is important to remember:
+
+- You must include a header with your intended action (Add/Delete/Update)
+- You must prefix new lines with `+` even when creating a new file
+"""

apply_patch_py-0.1.0/src/apply_patch_py/models.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import List, Optional
+
+
+@dataclass
+class UpdateFileChunk:
+    """
+    Represents a chunk of changes within a file update.
+    """
+
+    old_lines: List[str]
+    new_lines: List[str]
+    change_context: Optional[str] = None
+    is_end_of_file: bool = False
+
+
+@dataclass
+class Hunk:
+    """
+    Base class for a file operation in a patch.
+    """
+
+    path: Path
+
+
+@dataclass
+class AddFile(Hunk):
+    """
+    Operation to create a new file with specific content.
+    """
+
+    content: str
+
+
+@dataclass
+class DeleteFile(Hunk):
+    """
+    Operation to delete an existing file.
+    """
+
+    pass
+
+
+@dataclass
+class UpdateFile(Hunk):
+    """
+    Operation to update an existing file, optionally renaming it.
+    """
+
+    chunks: List[UpdateFileChunk]
+    move_to: Optional[Path] = None
+
+
+@dataclass
+class Patch:
+    hunks: List[Hunk]
+
+
+@dataclass
+class AffectedPaths:
+    added: List[Path] = field(default_factory=list)
+    modified: List[Path] = field(default_factory=list)
+    deleted: List[Path] = field(default_factory=list)
+    success: bool = True