patch-fixer 0.3.1__tar.gz → 0.3.3__tar.gz

patch_fixer-0.3.3/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: patch-fixer
+Version: 0.3.3
+Summary: Fixes erroneous git apply patches to the best of its ability.
+Maintainer-email: Alex Mueller <amueller474@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ajcm474/patch-fixer
+Project-URL: Issues, https://github.com/ajcm474/patch-fixer/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: GitPython
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: requests; extra == "test"
+Dynamic: license-file
+
+# patch-fixer
+So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch-fixer` is here to save the day... more or less.
+
+This tool can also split patches into separate files based on file lists, making it easy to selectively apply changes.
+
+## Installation
+```bash
+# Make sure you're using at least python 3.10
+python -m venv .venv/
+source .venv/bin/activate
+pip install patch-fixer
+```
+
+## Usage
+
+### Command Line Interface
+
+After installation, `patch-fixer` provides a unified command-line interface:
+
+#### Fixing broken patches:
+```bash
+patch-fixer fix original broken.patch fixed.patch
+```
+where:
+- `original` is the file or directory you were trying to patch
+- `broken.patch` is the malformed patch generated by the LLM
+- `fixed.patch` is the output file containing the (hopefully) fixed patch
+
+#### Splitting patches by file:
+```bash
+# Split with files specified on command line
+patch-fixer split input.patch included.patch excluded.patch -f file1.py file2.py
+
+# Split using a file list
+patch-fixer split input.patch included.patch excluded.patch -i files_to_include.txt
+```
+where:
+- `input.patch` is the patch file to split
+- `included.patch` will contain changes for the specified files
+- `excluded.patch` will contain changes for all other files
+- `-f` allows specifying files directly on the command line
+- `-i` reads the file list from a text file (one file per line)
+
+### Python API
+
+#### Fixing patches:
+```python
+from patch_fixer import fix_patch
+
+patch_file = "/path/to/broken.patch"
+original = "/path/to/original/state"    # file or directory being patched
+with open(patch_file, encoding="utf-8") as f:
+    patch_lines = f.readlines()
+    
+fixed_lines = fix_patch(patch_lines, original)
+output_file = "/path/to/fixed.patch"
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    f.writelines(fixed_lines)
+```
+
+#### Splitting patches:
+```python
+from patch_fixer import split_patch
+
+with open("input.patch", encoding="utf-8") as f:
+    patch_lines = f.readlines()
+
+# split to include only specific files
+files_to_include = ["./src/main.py", "./src/utils.py"]
+included, excluded = split_patch(patch_lines, files_to_include)
+
+# write the split patches
+with open("included.patch", 'w', encoding='utf-8') as f:
+    f.writelines(included)
+    
+with open("excluded.patch", 'w', encoding='utf-8') as f:
+    f.writelines(excluded)
+```
+
+## Local Testing
+```bash
+git clone https://github.com/ajcm474/patch-fixer.git
+cd patch-fixer
+pip install -e .[test]
+pytest
+```
+From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
+in bugfix versions as I like to use test-driven development to build out new features. 
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
+
+## License
+
+This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.3/README.md

@@ -0,0 +1,94 @@
+# patch-fixer
+So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch-fixer` is here to save the day... more or less.
+
+This tool can also split patches into separate files based on file lists, making it easy to selectively apply changes.
+
+## Installation
+```bash
+# Make sure you're using at least python 3.10
+python -m venv .venv/
+source .venv/bin/activate
+pip install patch-fixer
+```
+
+## Usage
+
+### Command Line Interface
+
+After installation, `patch-fixer` provides a unified command-line interface:
+
+#### Fixing broken patches:
+```bash
+patch-fixer fix original broken.patch fixed.patch
+```
+where:
+- `original` is the file or directory you were trying to patch
+- `broken.patch` is the malformed patch generated by the LLM
+- `fixed.patch` is the output file containing the (hopefully) fixed patch
+
+#### Splitting patches by file:
+```bash
+# Split with files specified on command line
+patch-fixer split input.patch included.patch excluded.patch -f file1.py file2.py
+
+# Split using a file list
+patch-fixer split input.patch included.patch excluded.patch -i files_to_include.txt
+```
+where:
+- `input.patch` is the patch file to split
+- `included.patch` will contain changes for the specified files
+- `excluded.patch` will contain changes for all other files
+- `-f` allows specifying files directly on the command line
+- `-i` reads the file list from a text file (one file per line)
+
+### Python API
+
+#### Fixing patches:
+```python
+from patch_fixer import fix_patch
+
+patch_file = "/path/to/broken.patch"
+original = "/path/to/original/state"    # file or directory being patched
+with open(patch_file, encoding="utf-8") as f:
+    patch_lines = f.readlines()
+    
+fixed_lines = fix_patch(patch_lines, original)
+output_file = "/path/to/fixed.patch"
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    f.writelines(fixed_lines)
+```
+
+#### Splitting patches:
+```python
+from patch_fixer import split_patch
+
+with open("input.patch", encoding="utf-8") as f:
+    patch_lines = f.readlines()
+
+# split to include only specific files
+files_to_include = ["./src/main.py", "./src/utils.py"]
+included, excluded = split_patch(patch_lines, files_to_include)
+
+# write the split patches
+with open("included.patch", 'w', encoding='utf-8') as f:
+    f.writelines(included)
+    
+with open("excluded.patch", 'w', encoding='utf-8') as f:
+    f.writelines(excluded)
+```
+
+## Local Testing
+```bash
+git clone https://github.com/ajcm474/patch-fixer.git
+cd patch-fixer
+pip install -e .[test]
+pytest
+```
+From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
+in bugfix versions as I like to use test-driven development to build out new features. 
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
+
+## License
+
+This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.3/patch_fixer/__init__.py

@@ -0,0 +1,2 @@
+from .patch_fixer import fix_patch
+from .split import split_patch

patch_fixer-0.3.3/patch_fixer/cli.py

@@ -0,0 +1,129 @@
+#!/usr/bin/env python3
+"""Command-line interface for patch-fixer."""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .patch_fixer import fix_patch
+from .split import split_patch
+
+
+def fix_command(args):
+    """Handle the fix command."""
+    with open(args.broken_patch, encoding='utf-8') as f:
+        patch_lines = f.readlines()
+
+    fixed_lines = fix_patch(patch_lines, args.original)
+
+    with open(args.output, 'w', encoding='utf-8') as f:
+        f.writelines(fixed_lines)
+
+    print(f"Fixed patch written to {args.output}")
+    return 0
+
+
+def split_command(args):
+    """Handle the split command."""
+    with open(args.patch_file, encoding='utf-8') as f:
+        patch_lines = f.readlines()
+
+    # read files to include from file or command line
+    if args.include_file:
+        with open(args.include_file, encoding='utf-8') as f:
+            files_to_include = [line.strip() for line in f if line.strip()]
+    else:
+        files_to_include = args.files or []
+
+    included, excluded = split_patch(patch_lines, files_to_include)
+
+    # write output files
+    with open(args.included_output, 'w', encoding='utf-8') as f:
+        f.writelines(included)
+
+    with open(args.excluded_output, 'w', encoding='utf-8') as f:
+        f.writelines(excluded)
+
+    print(f"Patch split into:")
+    print(f"  Included: {args.included_output} ({len(included)} lines)")
+    print(f"  Excluded: {args.excluded_output} ({len(excluded)} lines)")
+
+    return 0
+
+
+def main():
+    """Main entry point for the CLI."""
+    parser = argparse.ArgumentParser(
+        prog='patch-fixer',
+        description='Fix broken git patches or split them by file lists.'
+    )
+
+    subparsers = parser.add_subparsers(dest='command', help='Available commands')
+
+    # fix command
+    fix_parser = subparsers.add_parser(
+        'fix',
+        help='Fix a broken patch file'
+    )
+    fix_parser.add_argument(
+        'original',
+        help='Original file or directory that the patch applies to'
+    )
+    fix_parser.add_argument(
+        'broken_patch',
+        help='Path to the broken patch file'
+    )
+    fix_parser.add_argument(
+        'output',
+        help='Path where the fixed patch will be written'
+    )
+
+    # split command
+    split_parser = subparsers.add_parser(
+        'split',
+        help='Split a patch file based on file lists'
+    )
+    split_parser.add_argument(
+        'patch_file',
+        help='Path to the patch file to split'
+    )
+    split_parser.add_argument(
+        'included_output',
+        help='Output file for included files'
+    )
+    split_parser.add_argument(
+        'excluded_output',
+        help='Output file for excluded files'
+    )
+    split_parser.add_argument(
+        '-f', '--files',
+        nargs='*',
+        help='Files to include (can specify multiple)'
+    )
+    split_parser.add_argument(
+        '-i', '--include-file',
+        help='File containing list of files to include (one per line)'
+    )
+
+    # parse arguments
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    # dispatch to appropriate command
+    try:
+        if args.command == 'fix':
+            return fix_command(args)
+        elif args.command == 'split':
+            return split_command(args)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{patch_fixer-0.3.1 → patch_fixer-0.3.3}/patch_fixer/patch_fixer.py

@@ -204,7 +204,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
                     except MissingHunkError:
                         raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                                  f"\n\n{"".join(current_hunk)}")
+                                                  f"\n\n{''.join(current_hunk)}")
                     fixed_lines.append(fixed_header)
                     fixed_lines.extend(current_hunk)
                     current_hunk = []
@@ -415,7 +415,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                     ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
                 except MissingHunkError:
                     raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                              f"\n\n{"".join(current_hunk)}")
+                                              f"\n\n{''.join(current_hunk)}")
                 fixed_lines.append(fixed_header)
                 fixed_lines.extend(current_hunk)
                 current_hunk = []
@@ -437,7 +437,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
         ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context)
     except MissingHunkError:
         raise NotImplementedError(f"Could not find hunk in {current_file}:"
-                                  f"\n\n{"".join(current_hunk)}")
+                                  f"\n\n{''.join(current_hunk)}")
     fixed_lines.append(fixed_header)
     fixed_lines.extend(current_hunk)
 

patch_fixer-0.3.3/patch_fixer/split.py

@@ -0,0 +1,119 @@
+"""
+Idea:
+
+1. main function takes in:
+    a. patch file
+    b. list of files to split out
+2. reads patch file, splits based on file headers (assumed to be valid)
+3. for each file being patched:
+    a. if the file is in the list, send its hunks to output 1
+    b. otherwise send its hunks to output 2
+    c. hunks include all header lines so each output is a valid diff
+
+Could share some functionality with refactored, modular version of fix_patch
+"""
+
+import re
+from typing import List, Tuple
+
+from .patch_fixer import match_line, normalize_line, split_ab
+
+
+def get_file_path_from_diff(line: str) -> str:
+    """Extract the file path from a diff line."""
+    match_groups, line_type = match_line(line)
+    if line_type != "DIFF_LINE":
+        raise ValueError(f"Expected DIFF_LINE but got {line_type}")
+
+    # get the 'a' path (source file)
+    a_path, _ = split_ab(match_groups)
+    return a_path
+
+
+def split_patch(patch_lines: List[str], files_to_include: List[str]) -> Tuple[List[str], List[str]]:
+    """
+    Split a patch into two parts based on a list of files to include.
+
+    Parameters
+    ----------
+    patch_lines : List[str]
+        Lines of the patch file to split.
+    files_to_include : List[str]
+        List of file paths (relative, starting with ./) to include in the first output.
+        Files not in this list go to the second output.
+
+    Returns
+    -------
+    included_lines : List[str]
+        Lines for the patch containing only the included files.
+    excluded_lines : List[str]
+        Lines for the patch containing all other files.
+
+    Notes
+    -----
+    The function preserves all header information for each file's hunks
+    to ensure both output patches are valid. File paths are normalized
+    to start with './' for comparison purposes.
+
+    Raises
+    ------
+    ValueError
+        If the patch format is invalid or cannot be parsed.
+    """
+    if not patch_lines:
+        raise ValueError("Empty patch provided")
+
+    # normalize file paths to include
+    normalized_include = set()
+    for path in files_to_include:
+        if not path.startswith("./"):
+            path = f"./{path}"
+        normalized_include.add(path)
+
+    included_lines = []
+    excluded_lines = []
+    current_file_lines = []
+    current_file_path = None
+    in_file_block = False
+
+    for line in patch_lines:
+        match_groups, line_type = match_line(line)
+
+        if line_type == "DIFF_LINE":
+            # start of a new file block
+            if in_file_block and current_file_lines:
+                # output the previous file block
+                if current_file_path in normalized_include:
+                    included_lines.extend(current_file_lines)
+                else:
+                    excluded_lines.extend(current_file_lines)
+
+            # start collecting new file block
+            current_file_lines = [normalize_line(line)]
+            current_file_path = get_file_path_from_diff(line)
+            in_file_block = True
+
+        elif in_file_block:
+            # continue collecting lines for current file
+            current_file_lines.append(normalize_line(line))
+
+        else:
+            # lines before any diff (shouldn't happen in well-formed patches)
+            # add to both outputs to preserve any global headers
+            normalized = normalize_line(line)
+            included_lines.append(normalized)
+            excluded_lines.append(normalized)
+
+    # don't forget the last file block
+    if in_file_block and current_file_lines:
+        if current_file_path in normalized_include:
+            included_lines.extend(current_file_lines)
+        else:
+            excluded_lines.extend(current_file_lines)
+
+    # handle edge case where no files were split (no diff lines)
+    if not in_file_block:
+        # patch had no diff lines at all
+        return patch_lines, []
+
+    return included_lines, excluded_lines

patch_fixer-0.3.3/patch_fixer.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: patch-fixer
+Version: 0.3.3
+Summary: Fixes erroneous git apply patches to the best of its ability.
+Maintainer-email: Alex Mueller <amueller474@gmail.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/ajcm474/patch-fixer
+Project-URL: Issues, https://github.com/ajcm474/patch-fixer/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: GitPython
+Provides-Extra: test
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: requests; extra == "test"
+Dynamic: license-file
+
+# patch-fixer
+So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch-fixer` is here to save the day... more or less.
+
+This tool can also split patches into separate files based on file lists, making it easy to selectively apply changes.
+
+## Installation
+```bash
+# Make sure you're using at least python 3.10
+python -m venv .venv/
+source .venv/bin/activate
+pip install patch-fixer
+```
+
+## Usage
+
+### Command Line Interface
+
+After installation, `patch-fixer` provides a unified command-line interface:
+
+#### Fixing broken patches:
+```bash
+patch-fixer fix original broken.patch fixed.patch
+```
+where:
+- `original` is the file or directory you were trying to patch
+- `broken.patch` is the malformed patch generated by the LLM
+- `fixed.patch` is the output file containing the (hopefully) fixed patch
+
+#### Splitting patches by file:
+```bash
+# Split with files specified on command line
+patch-fixer split input.patch included.patch excluded.patch -f file1.py file2.py
+
+# Split using a file list
+patch-fixer split input.patch included.patch excluded.patch -i files_to_include.txt
+```
+where:
+- `input.patch` is the patch file to split
+- `included.patch` will contain changes for the specified files
+- `excluded.patch` will contain changes for all other files
+- `-f` allows specifying files directly on the command line
+- `-i` reads the file list from a text file (one file per line)
+
+### Python API
+
+#### Fixing patches:
+```python
+from patch_fixer import fix_patch
+
+patch_file = "/path/to/broken.patch"
+original = "/path/to/original/state"    # file or directory being patched
+with open(patch_file, encoding="utf-8") as f:
+    patch_lines = f.readlines()
+    
+fixed_lines = fix_patch(patch_lines, original)
+output_file = "/path/to/fixed.patch"
+
+with open(output_file, 'w', encoding='utf-8') as f:
+    f.writelines(fixed_lines)
+```
+
+#### Splitting patches:
+```python
+from patch_fixer import split_patch
+
+with open("input.patch", encoding="utf-8") as f:
+    patch_lines = f.readlines()
+
+# split to include only specific files
+files_to_include = ["./src/main.py", "./src/utils.py"]
+included, excluded = split_patch(patch_lines, files_to_include)
+
+# write the split patches
+with open("included.patch", 'w', encoding='utf-8') as f:
+    f.writelines(included)
+    
+with open("excluded.patch", 'w', encoding='utf-8') as f:
+    f.writelines(excluded)
+```
+
+## Local Testing
+```bash
+git clone https://github.com/ajcm474/patch-fixer.git
+cd patch-fixer
+pip install -e .[test]
+pytest
+```
+From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
+in bugfix versions as I like to use test-driven development to build out new features. 
+Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
+
+## License
+
+This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

{patch_fixer-0.3.1 → patch_fixer-0.3.3}/patch_fixer.egg-info/SOURCES.txt

@@ -2,11 +2,15 @@ LICENSE
 README.md
 pyproject.toml
 patch_fixer/__init__.py
+patch_fixer/cli.py
 patch_fixer/patch_fixer.py
+patch_fixer/split.py
 patch_fixer.egg-info/PKG-INFO
 patch_fixer.egg-info/SOURCES.txt
 patch_fixer.egg-info/dependency_links.txt
+patch_fixer.egg-info/entry_points.txt
 patch_fixer.egg-info/requires.txt
 patch_fixer.egg-info/top_level.txt
 tests/test_norm.py
-tests/test_repos.py
+tests/test_repos.py
+tests/test_split.py

patch_fixer-0.3.3/patch_fixer.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+patch-fixer = patch_fixer.cli:main

{patch_fixer-0.3.1 → patch_fixer-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "patch-fixer"
-version = "0.3.1"
+version = "0.3.3"
 description = "Fixes erroneous git apply patches to the best of its ability."
 maintainers = [
     {name = "Alex Mueller", email="amueller474@gmail.com"},
@@ -32,6 +32,9 @@ license-files = [
     'LICENSE'
 ]
 
+[project.scripts]
+patch-fixer = "patch_fixer.cli:main"
+
 [project.optional-dependencies]
 test = [
     "hypothesis",

{patch_fixer-0.3.1 → patch_fixer-0.3.3}/tests/test_norm.py

@@ -71,9 +71,20 @@ def test_normalize_line_hypothesis(line):
         result = normalize_line(line)
     except BadCarriageReturn:
         # must have an interior CR somewhere, or malformed ending
-        cr_condition = (("\r" in line[:-2])
-                        or (line.endswith("\r") and not line.endswith("\r\n"))
-                        or line.endswith("\n\r"))
+        # interior CR means: after removing any valid line ending, there's still a CR
+        if line.endswith("\r\n"):
+            core = line[:-2]
+        elif line.endswith("\r"):
+            core = line[:-1]
+        elif line.endswith("\n"):
+            core = line[:-1]
+        else:
+            core = line
+
+        cr_condition = (
+                "\r" in core  # CR in the core content
+                or line.endswith("\n\r")  # malformed LF+CR ending
+        )
         assert cr_condition, f"BadCarriageReturn raised unexpectedly for line: {line!r}"
     except ValueError:
         # must have an interior LF somewhere

patch_fixer-0.3.3/tests/test_split.py

@@ -0,0 +1,386 @@
+"""Tests for the split_patch functionality."""
+
+import pytest
+
+from patch_fixer.split import split_patch
+
+
+class TestSplitPatch:
+    """Test cases for split_patch function."""
+
+    def test_simple_split(self):
+        """Test basic splitting with two files."""
+        patch = [
+            "diff --git a/file1.txt b/file1.txt\n",
+            "index 1234567..abcdefg 100644\n",
+            "--- a/file1.txt\n",
+            "+++ b/file1.txt\n",
+            "@@ -1,3 +1,3 @@\n",
+            " line1\n",
+            "-old line\n",
+            "+new line\n",
+            " line3\n",
+            "diff --git a/file2.txt b/file2.txt\n",
+            "index 2234567..bbcdefg 100644\n",
+            "--- a/file2.txt\n",
+            "+++ b/file2.txt\n",
+            "@@ -1,2 +1,2 @@\n",
+            "-removed\n",
+            "+added\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file1.txt"])
+
+        # check that file1 is in included
+        assert "diff --git a/file1.txt b/file1.txt\n" in included
+        assert "+new line\n" in included
+
+        # check that file2 is in excluded
+        assert "diff --git a/file2.txt b/file2.txt\n" in excluded
+        assert "+added\n" in excluded
+
+        # check that files are not mixed
+        assert "file2.txt" not in "".join(included)
+        assert "file1.txt" not in "".join(excluded)
+
+    def test_split_with_multiple_includes(self):
+        """Test splitting with multiple files to include."""
+        patch = [
+            "diff --git a/file1.txt b/file1.txt\n",
+            "--- a/file1.txt\n",
+            "+++ b/file1.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old1\n",
+            "+new1\n",
+            "diff --git a/file2.txt b/file2.txt\n",
+            "--- a/file2.txt\n",
+            "+++ b/file2.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old2\n",
+            "+new2\n",
+            "diff --git a/file3.txt b/file3.txt\n",
+            "--- a/file3.txt\n",
+            "+++ b/file3.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old3\n",
+            "+new3\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file1.txt", "./file3.txt"])
+
+        # verify file1 and file3 are included
+        assert "file1.txt" in "".join(included)
+        assert "file3.txt" in "".join(included)
+        assert "+new1\n" in included
+        assert "+new3\n" in included
+
+        # verify file2 is excluded
+        assert "file2.txt" in "".join(excluded)
+        assert "+new2\n" in excluded
+        assert "file1.txt" not in "".join(excluded)
+        assert "file3.txt" not in "".join(excluded)
+
+    def test_split_with_no_includes(self):
+        """Test when no files match the include list."""
+        patch = [
+            "diff --git a/file1.txt b/file1.txt\n",
+            "--- a/file1.txt\n",
+            "+++ b/file1.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./nonexistent.txt"])
+
+        # all content should be in excluded
+        assert len(included) == 0
+        assert "file1.txt" in "".join(excluded)
+        assert "+new\n" in excluded
+
+    def test_split_with_all_includes(self):
+        """Test when all files match the include list."""
+        patch = [
+            "diff --git a/file1.txt b/file1.txt\n",
+            "--- a/file1.txt\n",
+            "+++ b/file1.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file1.txt"])
+
+        # all content should be in included
+        assert "file1.txt" in "".join(included)
+        assert "+new\n" in included
+        assert len(excluded) == 0
+
+    def test_split_preserves_headers(self):
+        """Test that all necessary headers are preserved."""
+        patch = [
+            "diff --git a/file.txt b/file.txt\n",
+            "index 1234567..abcdefg 100644\n",
+            "new file mode 100644\n",
+            "--- /dev/null\n",
+            "+++ b/file.txt\n",
+            "@@ -0,0 +1,2 @@\n",
+            "+new file\n",
+            "+content\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file.txt"])
+
+        # check all headers are preserved
+        assert "diff --git a/file.txt b/file.txt\n" in included
+        assert "index 1234567..abcdefg 100644\n" in included
+        assert "new file mode 100644\n" in included
+        assert "--- /dev/null\n" in included
+        assert "+++ b/file.txt\n" in included
+        assert "@@ -0,0 +1,2 @@\n" in included
+
+    def test_split_with_rename(self):
+        """Test splitting patches with file renames."""
+        patch = [
+            "diff --git a/old.txt b/new.txt\n",
+            "similarity index 95%\n",
+            "rename from old.txt\n",
+            "rename to new.txt\n",
+            "index 1234567..abcdefg 100644\n",
+            "--- a/old.txt\n",
+            "+++ b/new.txt\n",
+            "@@ -1,3 +1,3 @@\n",
+            " same line\n",
+            "-old content\n",
+            "+new content\n",
+        ]
+
+        # include based on old name (source file)
+        included, excluded = split_patch(patch, ["./old.txt"])
+
+        assert "rename from old.txt\n" in included
+        assert "rename to new.txt\n" in included
+        assert len(excluded) == 0
+
+    def test_split_with_binary_files(self):
+        """Test splitting patches containing binary files."""
+        patch = [
+            "diff --git a/image.png b/image.png\n",
+            "index 1234567..abcdefg 100644\n",
+            "Binary files a/image.png and b/image.png differ\n",
+            "diff --git a/text.txt b/text.txt\n",
+            "--- a/text.txt\n",
+            "+++ b/text.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./image.png"])
+
+        assert "Binary files a/image.png and b/image.png differ\n" in included
+        assert "text.txt" in "".join(excluded)
+        assert "image.png" not in "".join(excluded)
+
+    def test_normalization_of_paths(self):
+        """Test that file paths are normalized correctly."""
+        patch = [
+            "diff --git a/file.txt b/file.txt\n",
+            "--- a/file.txt\n",
+            "+++ b/file.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        # test without ./ prefix
+        included1, excluded1 = split_patch(patch, ["file.txt"])
+        assert "file.txt" in "".join(included1)
+        assert len(excluded1) == 0
+
+        # test with ./ prefix
+        included2, excluded2 = split_patch(patch, ["./file.txt"])
+        assert "file.txt" in "".join(included2)
+        assert len(excluded2) == 0
+
+        # both should produce same result
+        assert included1 == included2
+        assert excluded1 == excluded2
+
+    def test_empty_patch(self):
+        """Test behavior with empty patch."""
+        with pytest.raises(ValueError, match="Empty patch provided"):
+            split_patch([], ["./file.txt"])
+
+    def test_invalid_diff_format(self):
+        """Test behavior with invalid diff format."""
+        invalid_patch = [
+            "not a valid diff line\n",
+            "diff --git a/file.txt b/file.txt\n",
+            "--- a/file.txt\n",
+            "+++ b/file.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        # should handle gracefully - non-diff lines before first diff
+        included, excluded = split_patch(invalid_patch, ["./file.txt"])
+
+        # the invalid line should be in both outputs (global header behavior)
+        assert "not a valid diff line\n" in included
+        assert "not a valid diff line\n" in excluded
+
+    def test_no_files_in_include_list(self):
+        """Test when include list is empty."""
+        patch = [
+            "diff --git a/file.txt b/file.txt\n",
+            "--- a/file.txt\n",
+            "+++ b/file.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+        ]
+
+        included, excluded = split_patch(patch, [])
+
+        # everything should go to excluded
+        assert len(included) == 0
+        assert "file.txt" in "".join(excluded)
+
+    def test_patch_with_no_diff_lines(self):
+        """Test patch that has no actual diff lines."""
+        patch = [
+            "This is a comment\n",
+            "Another comment\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file.txt"])
+
+        # non-diff lines should appear in original form
+        assert patch == included
+        assert len(excluded) == 0
+
+    def test_multiple_hunks_same_file(self):
+        """Test that multiple hunks for the same file stay together."""
+        patch = [
+            "diff --git a/file.txt b/file.txt\n",
+            "--- a/file.txt\n",
+            "+++ b/file.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old1\n",
+            "+new1\n",
+            "@@ -10,1 +10,1 @@\n",
+            "-old2\n",
+            "+new2\n",
+            "@@ -20,1 +20,1 @@\n",
+            "-old3\n",
+            "+new3\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./file.txt"])
+
+        # all hunks should be in included
+        assert "+new1\n" in included
+        assert "+new2\n" in included
+        assert "+new3\n" in included
+        assert len(excluded) == 0
+
+    def test_file_deletion(self):
+        """Test splitting patches with file deletions."""
+        patch = [
+            "diff --git a/deleted.txt b/deleted.txt\n",
+            "deleted file mode 100644\n",
+            "index 1234567..0000000\n",
+            "--- a/deleted.txt\n",
+            "+++ /dev/null\n",
+            "@@ -1,3 +0,0 @@\n",
+            "-line1\n",
+            "-line2\n",
+            "-line3\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./deleted.txt"])
+
+        assert "deleted file mode 100644\n" in included
+        assert "+++ /dev/null\n" in included
+        assert "-line1\n" in included
+        assert len(excluded) == 0
+
+    def test_file_creation(self):
+        """Test splitting patches with new file creation."""
+        patch = [
+            "diff --git a/new.txt b/new.txt\n",
+            "new file mode 100644\n",
+            "index 0000000..1234567\n",
+            "--- /dev/null\n",
+            "+++ b/new.txt\n",
+            "@@ -0,0 +1,3 @@\n",
+            "+line1\n",
+            "+line2\n",
+            "+line3\n",
+        ]
+
+        included, excluded = split_patch(patch, ["./new.txt"])
+
+        assert "new file mode 100644\n" in included
+        assert "--- /dev/null\n" in included
+        assert "+line1\n" in included
+        assert len(excluded) == 0
+
+    def test_complex_patch(self):
+        """Test a complex patch with various file operations."""
+        patch = [
+            "diff --git a/modified.txt b/modified.txt\n",
+            "index 1234567..abcdefg 100644\n",
+            "--- a/modified.txt\n",
+            "+++ b/modified.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-old\n",
+            "+new\n",
+            "diff --git a/created.txt b/created.txt\n",
+            "new file mode 100644\n",
+            "index 0000000..2234567\n",
+            "--- /dev/null\n",
+            "+++ b/created.txt\n",
+            "@@ -0,0 +1,1 @@\n",
+            "+created content\n",
+            "diff --git a/deleted.txt b/deleted.txt\n",
+            "deleted file mode 100644\n",
+            "index 3234567..0000000\n",
+            "--- a/deleted.txt\n",
+            "+++ /dev/null\n",
+            "@@ -1,1 +0,0 @@\n",
+            "-deleted content\n",
+            "diff --git a/renamed_old.txt b/renamed_new.txt\n",
+            "similarity index 90%\n",
+            "rename from renamed_old.txt\n",
+            "rename to renamed_new.txt\n",
+            "index 4234567..5234567\n",
+            "--- a/renamed_old.txt\n",
+            "+++ b/renamed_new.txt\n",
+            "@@ -1,1 +1,1 @@\n",
+            "-before rename\n",
+            "+after rename\n",
+        ]
+
+        # include modified and renamed files
+        included, excluded = split_patch(patch, ["./modified.txt", "./renamed_old.txt"])
+
+        # check included has modified and renamed
+        assert "modified.txt" in "".join(included)
+        assert "renamed_old.txt" in "".join(included)
+        assert "+new\n" in included
+        assert "+after rename\n" in included
+
+        # check excluded has created and deleted
+        assert "created.txt" in "".join(excluded)
+        assert "deleted.txt" in "".join(excluded)
+        assert "+created content\n" in excluded
+        assert "-deleted content\n" in excluded
+
+        # check no cross-contamination
+        assert "created.txt" not in "".join(included)
+        assert "deleted.txt" not in "".join(included)
+        assert "modified.txt" not in "".join(excluded)
+        assert "renamed" not in "".join(excluded)

patch_fixer-0.3.1/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: patch-fixer
-Version: 0.3.1
-Summary: Fixes erroneous git apply patches to the best of its ability.
-Maintainer-email: Alex Mueller <amueller474@gmail.com>
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/ajcm474/patch-fixer
-Project-URL: Issues, https://github.com/ajcm474/patch-fixer/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Software Development
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: GitPython
-Provides-Extra: test
-Requires-Dist: hypothesis; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: requests; extra == "test"
-Dynamic: license-file
-
-# patch-fixer
-So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch_fixer.py` is here to save the day... more or less.
-
-## Installation
-```bash
-# Make sure you're using at least python 3.10
-python -m venv .venv/
-source .venv/bin/activate
-pip install patch-fixer
-```
-
-## Usage
-### API:
-```python
->>> from patch_fixer import fix_patch
->>>
->>> patch_file = "/path/to/broken.patch"
->>> original = "/path/to/original/state"    # file or directory being patched
->>> with open(patch_file, encoding="utf-8") as f:
-...     patch_lines = f.readlines()
-...     
->>> fixed_lines = fix_patch(patch_lines, original)
->>> output_file = "/path/to/fixed.patch"
->>>
->>> with open(output_file, 'w', encoding='utf-8') as f:
-...     f.writelines(fixed_lines)
->>>
-```
-### Command line:
-```bash
-python patch_fixer/patch_fixer.py original broken.patch fixed.patch
-```
-where `original` is the file or directory you were trying to patch, 
-`broken.patch` is the malformed patch generated by the LLM, 
-and `fixed.patch` is the output file containing the (hopefully) fixed patch.
-
-## Local Testing
-```bash
-git clone https://github.com/ajcm474/patch-fixer.git
-cd patch-fixer
-pip install -e .[test]
-pytest
-```
-From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
-in bugfix versions as I like to use test-driven development to build out new features. 
-Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
-
-## License
-
-This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.1/README.md

@@ -1,50 +0,0 @@
-# patch-fixer
-So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch_fixer.py` is here to save the day... more or less.
-
-## Installation
-```bash
-# Make sure you're using at least python 3.10
-python -m venv .venv/
-source .venv/bin/activate
-pip install patch-fixer
-```
-
-## Usage
-### API:
-```python
->>> from patch_fixer import fix_patch
->>>
->>> patch_file = "/path/to/broken.patch"
->>> original = "/path/to/original/state"    # file or directory being patched
->>> with open(patch_file, encoding="utf-8") as f:
-...     patch_lines = f.readlines()
-...     
->>> fixed_lines = fix_patch(patch_lines, original)
->>> output_file = "/path/to/fixed.patch"
->>>
->>> with open(output_file, 'w', encoding='utf-8') as f:
-...     f.writelines(fixed_lines)
->>>
-```
-### Command line:
-```bash
-python patch_fixer/patch_fixer.py original broken.patch fixed.patch
-```
-where `original` is the file or directory you were trying to patch, 
-`broken.patch` is the malformed patch generated by the LLM, 
-and `fixed.patch` is the output file containing the (hopefully) fixed patch.
-
-## Local Testing
-```bash
-git clone https://github.com/ajcm474/patch-fixer.git
-cd patch-fixer
-pip install -e .[test]
-pytest
-```
-From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
-in bugfix versions as I like to use test-driven development to build out new features. 
-Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
-
-## License
-
-This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.

patch_fixer-0.3.1/patch_fixer/__init__.py

@@ -1 +0,0 @@
-from .patch_fixer import fix_patch

patch_fixer-0.3.1/patch_fixer.egg-info/PKG-INFO

@@ -1,79 +0,0 @@
-Metadata-Version: 2.4
-Name: patch-fixer
-Version: 0.3.1
-Summary: Fixes erroneous git apply patches to the best of its ability.
-Maintainer-email: Alex Mueller <amueller474@gmail.com>
-License-Expression: Apache-2.0
-Project-URL: Homepage, https://github.com/ajcm474/patch-fixer
-Project-URL: Issues, https://github.com/ajcm474/patch-fixer/issues
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Software Development
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: GitPython
-Provides-Extra: test
-Requires-Dist: hypothesis; extra == "test"
-Requires-Dist: pytest; extra == "test"
-Requires-Dist: requests; extra == "test"
-Dynamic: license-file
-
-# patch-fixer
-So you asked an LLM to generate a code diff, tried to apply it with `git apply`, and got a bunch of malformed patch errors? Well fear no more, `patch_fixer.py` is here to save the day... more or less.
-
-## Installation
-```bash
-# Make sure you're using at least python 3.10
-python -m venv .venv/
-source .venv/bin/activate
-pip install patch-fixer
-```
-
-## Usage
-### API:
-```python
->>> from patch_fixer import fix_patch
->>>
->>> patch_file = "/path/to/broken.patch"
->>> original = "/path/to/original/state"    # file or directory being patched
->>> with open(patch_file, encoding="utf-8") as f:
-...     patch_lines = f.readlines()
-...     
->>> fixed_lines = fix_patch(patch_lines, original)
->>> output_file = "/path/to/fixed.patch"
->>>
->>> with open(output_file, 'w', encoding='utf-8') as f:
-...     f.writelines(fixed_lines)
->>>
-```
-### Command line:
-```bash
-python patch_fixer/patch_fixer.py original broken.patch fixed.patch
-```
-where `original` is the file or directory you were trying to patch, 
-`broken.patch` is the malformed patch generated by the LLM, 
-and `fixed.patch` is the output file containing the (hopefully) fixed patch.
-
-## Local Testing
-```bash
-git clone https://github.com/ajcm474/patch-fixer.git
-cd patch-fixer
-pip install -e .[test]
-pytest
-```
-From version `0.3.0` onward (at least until version `1.0`), some test failures are expected
-in bugfix versions as I like to use test-driven development to build out new features. 
-Please only report test failures if the same test existed and passed in the most recent `0.x.0` version.
-
-## License
-
-This is free and open source software, released under the Apache 2.0 License. See `LICENSE` for details.