patch-fixer 0.3.3__py3-none-any.whl → 0.4.0__py3-none-any.whl

patch_fixer/cli.py

@@ -14,7 +14,12 @@ def fix_command(args):
     with open(args.broken_patch, encoding='utf-8') as f:
         patch_lines = f.readlines()
 
-    fixed_lines = fix_patch(patch_lines, args.original)
+    fixed_lines = fix_patch(
+        patch_lines,
+        args.original,
+        fuzzy=args.fuzzy,
+        add_newline=args.add_newline
+    )
 
     with open(args.output, 'w', encoding='utf-8') as f:
         f.writelines(fixed_lines)
@@ -77,6 +82,16 @@ def main():
         'output',
         help='Path where the fixed patch will be written'
     )
+    fix_parser.add_argument(
+        '--fuzzy',
+        action='store_true',
+        help='Enable fuzzy string matching when finding hunks in original files'
+    )
+    fix_parser.add_argument(
+        '--add-newline',
+        action='store_true',
+        help='Add final newline when processing "No newline at end of file" markers'
+    )
 
     # split command
     split_parser = subparsers.add_parser(

patch_fixer/patch_fixer.py

@@ -2,6 +2,7 @@
 import os
 import re
 import sys
+import warnings
 from pathlib import Path
 
 from git import Repo
@@ -16,13 +17,49 @@ regexes = {
     "RENAME_TO": re.compile(rf'rename to ({path_regex})'),
     "FILE_HEADER_START": re.compile(rf'--- (a/{path_regex}|/dev/null)'),
     "FILE_HEADER_END": re.compile(rf'\+\+\+ (b/{path_regex}|/dev/null)'),
-    "HUNK_HEADER": re.compile(r'^@@ -(\d+),(\d+) \+(\d+),(\d+) @@(.*)$'),
+    "HUNK_HEADER": re.compile(r'^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$'),
     "END_LINE": re.compile(r'\')
 }
 
 
-class MissingHunkError(Exception):
-    pass
+class HunkErrorBase(Exception):
+    def __init__(self, hunk_lines, file="(unknown file)"):
+        super().__init__()
+        self.hunk = "".join(hunk_lines)
+        self.file = file
+
+    def format_hunk_for_error(self):
+        """Format hunk for error messages, showing only context and deletion lines."""
+        error_lines = []
+        for line in self.hunk.splitlines(keepends=True):
+            if line.startswith((' ', '-')):  # context or deletion lines
+                error_lines.append(line)
+            # skip addition lines (+) as they shouldn't be in the original file
+        return ''.join(error_lines)
+
+    def add_file(self, file):
+        self.file = file
+
+
+class MissingHunkError(HunkErrorBase):
+    def __str__(self):
+        return (f"Could not find hunk in {self.file}:"
+                f"\n================================"
+                f"\n{self.format_hunk_for_error()}"
+                f"================================")
+
+
+class OutOfOrderHunk(HunkErrorBase):
+    def __init__(self, hunk_lines, prev_header, file="(unknown file)"):
+        super().__init__(hunk_lines, file)
+        self.prev_header = prev_header
+
+    def __str__(self):
+        return (f"Out of order hunk in {self.file}:"
+                f"\n==============================="
+                f"\n{self.format_hunk_for_error()}"
+                f"==============================="
+                f"\nOccurs before previous hunk with header {self.prev_header}")
 
 
 class BadCarriageReturn(ValueError):
@@ -61,11 +98,37 @@ def normalize_line(line):
     return core + "\n"
 
 
-def find_hunk_start(context_lines, original_lines):
+def fuzzy_line_similarity(line1, line2, threshold=0.8):
+    """Calculate similarity between two lines using a simple ratio."""
+    l1, l2 = line1.strip(), line2.strip()
+
+    # empty strings are identical
+    if len(l1) == 0 and len(l2) == 0:
+        return 1.0
+
+    if l1 == l2:
+        return 1.0
+
+    if len(l1) == 0 or len(l2) == 0:
+        return 0.0
+
+    # count common characters
+    common = 0
+    for char in set(l1) & set(l2):
+        common += min(l1.count(char), l2.count(char))
+
+    total_chars = len(l1) + len(l2)
+    return (2.0 * common) / total_chars if total_chars > 0 else 0.0
+
+
+def find_hunk_start(context_lines, original_lines, fuzzy=False):
     """Search original_lines for context_lines and return start line index (0-based)."""
     ctx = []
     for line in context_lines:
-        if line.startswith(" "):
+        if regexes["END_LINE"].match(line):
+            # "" is just git metadata; skip
+            continue
+        elif line.startswith(" "):
             ctx.append(line.lstrip(" "))
         elif line.startswith("-"):
             # can't use lstrip; we want to keep other dashes in the line
@@ -74,12 +137,47 @@ def find_hunk_start(context_lines, original_lines):
             ctx.append(line)
     if not ctx:
         raise ValueError("Cannot search for empty hunk.")
+
+    # first try exact matching
     for i in range(len(original_lines) - len(ctx) + 1):
         # this part will fail if the diff is malformed beyond hunk header
-        equal_lines = [original_lines[i+j].strip() == ctx[j].strip() for j in range(len(ctx))]
+        equal_lines = [original_lines[i + j].strip() == ctx[j].strip() for j in range(len(ctx))]
         if all(equal_lines):
             return i
-    return 0
+
+    # try with more flexible whitespace matching
+    for i in range(len(original_lines) - len(ctx) + 1):
+        equal_lines = []
+        for j in range(len(ctx)):
+            orig_line = original_lines[i + j].strip()
+            ctx_line = ctx[j].strip()
+            # normalize whitespace: convert multiple spaces/tabs to single space
+            orig_normalized = ' '.join(orig_line.split())
+            ctx_normalized = ' '.join(ctx_line.split())
+            equal_lines.append(orig_normalized == ctx_normalized)
+        if all(equal_lines):
+            return i
+
+    # if fuzzy matching is enabled and exact match failed, try fuzzy match
+    if fuzzy:
+        best_match_score = 0.0
+        best_match_pos = 0
+
+        for i in range(len(original_lines) - len(ctx) + 1):
+            total_similarity = 0.0
+            for j in range(len(ctx)):
+                similarity = fuzzy_line_similarity(original_lines[i + j], ctx[j])
+                total_similarity += similarity
+
+            avg_similarity = total_similarity / len(ctx)
+            if avg_similarity > best_match_score and avg_similarity > 0.6:
+                best_match_score = avg_similarity
+                best_match_pos = i
+
+        if best_match_score > 0.6:
+            return best_match_pos
+
+    raise MissingHunkError(context_lines)
 
 
 def match_line(line):
@@ -111,24 +209,76 @@ def reconstruct_file_header(diff_line, header_type):
             raise ValueError(f"Unsupported header type: {header_type}")
 
 
-def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context):
+def find_all_hunk_starts(hunk_lines, search_lines, fuzzy=False):
+    """Return all line indices in search_lines where this hunk matches."""
+    matches = []
+    start = 0
+    while True:
+        try:
+            idx = find_hunk_start(hunk_lines, search_lines[start:], fuzzy=fuzzy)
+            matches.append(start + idx)
+            start += idx + 1
+        except MissingHunkError:
+            break
+    return matches
+
+
+def capture_hunk(current_hunk, original_lines, offset, last_hunk, old_header, fuzzy=False):
+    """
+    Try to locate the hunk's true position in the original file.
+    If multiple possible matches exist, pick the one closest to the expected
+    (possibly corrupted) line number derived from the old hunk header.
+    """
+    # extract needed info from old header match groups
+    expected_old_start = int(old_header[0]) if old_header else 0
+    try:
+        hunk_context = old_header[4]
+    except IndexError:
+        hunk_context = ""
+
     # compute line counts
     old_count = sum(1 for l in current_hunk if l.startswith((' ', '-')))
     new_count = sum(1 for l in current_hunk if l.startswith((' ', '+')))
 
     if old_count > 0:
-        # compute starting line in original file
-        old_start = find_hunk_start(current_hunk, original_lines) + 1
-
-        # if the line number descends, we either have a bad match or a new file
-        if old_start < last_hunk:
-            raise MissingHunkError
+        search_index = last_hunk
+        search_lines = original_lines[search_index:]
+
+        # gather *all* possible matches
+        matches = find_all_hunk_starts(current_hunk, search_lines, fuzzy=fuzzy)
+        if matches:
+            # rebase to file line numbers (1-indexed later)
+            candidate_positions = [m + search_index for m in matches]
+
+            if expected_old_start:
+                # choose the one closest to the expected position
+                old_start = min(
+                    candidate_positions,
+                    key=lambda pos: abs(pos + 1 - expected_old_start),
+                ) + 1  # convert to 1-indexed
+            else:
+                # pick first match if no expected line info
+                old_start = candidate_positions[0] + 1
         else:
-            if new_count == 0:
-                # complete deletion of remaining content
-                new_start = 0
+            # try from start of file as fallback
+            matches = find_all_hunk_starts(current_hunk, original_lines, fuzzy=fuzzy)
+            if not matches:
+                raise MissingHunkError(current_hunk)
+            if expected_old_start:
+                old_start = (
+                    min(matches, key=lambda pos: abs(pos + 1 - expected_old_start)) + 1
+                )
             else:
-                new_start = old_start + offset
+                old_start = matches[0] + 1
+
+        if old_start < last_hunk + 1:
+            raise OutOfOrderHunk(current_hunk, original_lines[last_hunk])
+
+        if new_count == 0:
+            # complete deletion of remaining content
+            new_start = 0
+        else:
+            new_start = old_start + offset
     else:
         # old count of zero can only mean file creation, since adding lines to
         # an existing file requires surrounding context lines without a +
@@ -137,17 +287,43 @@ def capture_hunk(current_hunk, original_lines, offset, last_hunk, hunk_context):
 
     offset += (new_count - old_count)
 
-    last_hunk = old_start
+    last_hunk += (old_start - last_hunk)
 
-    # write corrected header
-    fixed_header = f"@@ -{old_start},{old_count} +{new_start},{new_count} @@{hunk_context}\n"
+    # use condensed header if it's only one line
+    old_part = f"{old_start},{old_count}" if old_count != 1 else f"{old_start}"
+    new_part = f"{new_start},{new_count}" if new_count != 1 else f"{new_start}"
+
+    fixed_header = f"@@ -{old_part} +{new_part} @@{hunk_context}\n"
 
     return fixed_header, offset, last_hunk
 
 
+def read_file_with_fallback_encoding(file_path):
+    """Read file with UTF-8, falling back to other encodings if needed."""
+    encodings = ['utf-8', 'latin-1', 'cp1252', 'iso-8859-1']
+
+    for encoding in encodings:
+        try:
+            with open(file_path, 'r', encoding=encoding) as f:
+                return f.readlines()
+        except UnicodeDecodeError:
+            continue
+
+    # If all encodings fail, read as binary and replace problematic characters
+    with open(file_path, 'rb') as f:
+        content = f.read()
+        # Decode with UTF-8, replacing errors
+        text_content = content.decode('utf-8', errors='replace')
+        return text_content.splitlines(keepends=True)
+
+
 def regenerate_index(old_path, new_path, cur_dir):
     repo = Repo(cur_dir)
-    mode = " 100644"     # TODO: check if mode can be a different number
+
+    # Common git file modes: 100644 (regular file), 100755 (executable file),
+    # 120000 (symbolic link), 160000 (submodule), 040000 (tree/directory)
+    # TODO: guess mode based on above information
+    mode = " 100644"
 
     # file deletion
     if new_path == "/dev/null":
@@ -164,12 +340,15 @@ def regenerate_index(old_path, new_path, cur_dir):
     return f"index {old_sha}..{new_sha}{mode}\n"
 
 
-def fix_patch(patch_lines, original, remove_binary=False):
+def fix_patch(patch_lines, original, remove_binary=False, fuzzy=False, add_newline=False):
     dir_mode = os.path.isdir(original)
     original_path = Path(original).absolute()
 
     # make relative paths in the diff work
-    os.chdir(original_path)
+    if dir_mode:
+        os.chdir(original_path)
+    else:
+        os.chdir(original_path.parent)
 
     fixed_lines = []
     current_hunk = []
@@ -186,7 +365,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
     similarity_index = None
     missing_index = False
     binary_file = False
-    hunk_context = ""
+    current_hunk_header = ()
     original_lines = []
     file_loaded = False
 
@@ -201,10 +380,10 @@ def fix_patch(patch_lines, original, remove_binary=False):
                             fixed_header,
                             offset,
                             last_hunk
-                        ) = 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)}")
+                        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, current_hunk_header, fuzzy=fuzzy)
+                    except (MissingHunkError, OutOfOrderHunk) as e:
+                        e.add_file(current_file)
+                        raise e
                     fixed_lines.append(fixed_header)
                     fixed_lines.extend(current_hunk)
                     current_hunk = []
@@ -224,7 +403,12 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 last_mode = i
                 fixed_lines.append(normalize_line(line))
             case "INDEX_LINE":
-                # TODO: verify that mode is present for anything but deletion
+                # mode should be present in index line for all operations except file deletion
+                # for deletions, the mode is omitted since the file no longer exists
+                index_line = normalize_line(line).strip()
+                if not index_line.endswith("..0000000") and not re.search(r' [0-7]{6}$', index_line):
+                    # TODO: this is the right idea, but a poor implementation
+                    pass
                 last_index = i
                 similarity_index = match_groups[0]
                 if similarity_index:
@@ -238,7 +422,9 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 fixed_lines.append(normalize_line(line))
             case "RENAME_FROM":
                 if not look_for_rename:
-                    pass    # TODO: handle missing index line
+                    # handle case where rename from appears without corresponding index line
+                    # this may indicate a malformed patch, but we can try to continue
+                    warnings.warn(f"Warning: 'rename from' found without expected index line at line {i+1}")
                 if binary_file:
                     raise NotImplementedError("Renaming binary files not yet supported")
                 if last_index != i - 1:
@@ -252,7 +438,10 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 offset = 0
                 last_hunk = 0
                 if not Path.exists(current_path):
-                    # TODO: verify whether this block is necessary at all
+                    # this is meant to handle cases where the source file
+                    # doesn't exist (e.g., when applying a patch that renames
+                    # a file created earlier in the same patch)
+                    # TODO: but really, does that ever happen???
                     fixed_lines.append(normalize_line(line))
                     look_for_rename = True
                     file_loaded = False
@@ -260,8 +449,8 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 if not current_path.is_file():
                     raise IsADirectoryError(f"Rename from header points to a directory, not a file: {current_file}")
                 if dir_mode or current_path == original_path:
-                    with open(current_path, encoding='utf-8') as f:
-                        original_lines = [l.rstrip('\n') for l in f.readlines()]
+                    file_lines = read_file_with_fallback_encoding(current_path)
+                    original_lines = [l.rstrip('\n') for l in file_lines]
                     fixed_lines.append(normalize_line(line))
                     file_loaded = True
                 else:
@@ -273,7 +462,12 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         last_index = i - 2
                     else:
                         raise NotImplementedError("Missing `rename from` header not yet supported.")
-                # TODO: do something sensible if `look_for_rename` is false
+                if not look_for_rename:
+                    # if we're not looking for a rename but encounter "rename to",
+                    # this indicates a malformed patch - log warning but continue
+                    warnings.warn(
+                        f"Warning: unexpected 'rename to' found at line {i + 1} without corresponding 'rename from'"
+                    )
                 current_file = match_groups[0]
                 current_path = Path(current_file).absolute()
                 if current_file and current_path.is_dir():
@@ -315,8 +509,8 @@ def fix_patch(patch_lines, original, remove_binary=False):
                     raise IsADirectoryError(f"File header start points to a directory, not a file: {current_file}")
                 if not file_loaded:
                     if dir_mode or Path(current_file) == Path(original):
-                        with open(current_file, encoding='utf-8') as f:
-                            original_lines = [l.rstrip('\n') for l in f.readlines()]
+                        file_lines = read_file_with_fallback_encoding(current_path)
+                        original_lines = [l.rstrip('\n') for l in file_lines]
                         file_loaded = True
                     else:
                         raise FileNotFoundError(f"Filename {current_file} in header does not match argument {original}")
@@ -404,7 +598,7 @@ def fix_patch(patch_lines, original, remove_binary=False):
                 # we can't fix the hunk header before we've captured a hunk
                 if first_hunk:
                     first_hunk = False
-                    hunk_context = match_groups[4]
+                    current_hunk_header = match_groups
                     continue
 
                 try:
@@ -412,19 +606,22 @@ def fix_patch(patch_lines, original, remove_binary=False):
                         fixed_header,
                         offset,
                         last_hunk
-                    ) = 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)}")
+                    ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, current_hunk_header, fuzzy=fuzzy)
+                except (MissingHunkError, OutOfOrderHunk) as e:
+                    e.add_file(current_file)
+                    raise e
                 fixed_lines.append(fixed_header)
                 fixed_lines.extend(current_hunk)
                 current_hunk = []
-                hunk_context = match_groups[4]
+                current_hunk_header = match_groups
             case "END_LINE":
-                # TODO: add newline at end of file if user requests
-                fixed_lines.append(normalize_line(line))
+                # if user requested, add a newline at end of file when this marker is present
+                if add_newline:
+                    fixed_lines.append("\n")
+                else:
+                    current_hunk.append(normalize_line(line))
             case _:
-                # TODO: fuzzy string matching
+                # TODO: fix fuzzy string matching to be less granular
                 # this is a normal line, add to current hunk
                 current_hunk.append(normalize_line(line))
 
@@ -434,15 +631,18 @@ def fix_patch(patch_lines, original, remove_binary=False):
             fixed_header,
             offset,
             last_hunk
-        ) = 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)}")
+        ) = capture_hunk(current_hunk, original_lines, offset, last_hunk, current_hunk_header, fuzzy=fuzzy)
+    except (MissingHunkError, OutOfOrderHunk) as e:
+        e.add_file(current_file)
+        raise e
     fixed_lines.append(fixed_header)
     fixed_lines.extend(current_hunk)
 
-    # if original file didn't end with a newline, strip out the newline here
-    if original_lines and not original_lines[-1].endswith("\n"):
+    # if original file didn't end with a newline, strip out the newline here,
+    # unless user explicitly requested to add final newline
+    if (not add_newline and
+            ((original_lines and not original_lines[-1].endswith("\n")) or
+             (fixed_lines and len(original_lines) == 0))):
         fixed_lines[-1] = fixed_lines[-1].rstrip("\n")
 
     return fixed_lines

{patch_fixer-0.3.3.dist-info → patch_fixer-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-fixer
-Version: 0.3.3
+Version: 0.4.0
 Summary: Fixes erroneous git apply patches to the best of its ability.
 Maintainer-email: Alex Mueller <amueller474@gmail.com>
 License-Expression: Apache-2.0
@@ -55,6 +55,11 @@ where:
 - `broken.patch` is the malformed patch generated by the LLM
 - `fixed.patch` is the output file containing the (hopefully) fixed patch
 
+Options:
+- `--fuzzy`: enable fuzzy string matching for better context matching (experimental)
+- `--add-newline`: add final newlines when processing "No newline at end of file" markers
+
+
 #### Splitting patches by file:
 ```bash
 # Split with files specified on command line
@@ -81,9 +86,16 @@ original = "/path/to/original/state"    # file or directory being patched
 with open(patch_file, encoding="utf-8") as f:
     patch_lines = f.readlines()
     
+# basic usage
 fixed_lines = fix_patch(patch_lines, original)
-output_file = "/path/to/fixed.patch"
 
+# with fuzzy matching enabled
+fixed_lines = fix_patch(patch_lines, original, fuzzy=True)
+
+# with final newline addition
+fixed_lines = fix_patch(patch_lines, original, add_newline=True)
+
+output_file = "/path/to/fixed.patch"
 with open(output_file, 'w', encoding='utf-8') as f:
     f.writelines(fixed_lines)
 ```
@@ -107,6 +119,13 @@ with open("excluded.patch", 'w', encoding='utf-8') as f:
     f.writelines(excluded)
 ```
 
+## Known Limitations
+
+- When fixing patches with missing `index` lines, the tool requires the files to be in a git repository to regenerate the index. This is only needed for file deletions and renames.
+- `patch-fixer` assumes the patch follows git's unified diff format.
+- Current implementation is not very robust to corrupted hunk content
+  - Much more comprehensive fuzzy string matching is planned
+
 ## Local Testing
 ```bash
 git clone https://github.com/ajcm474/patch-fixer.git

patch_fixer-0.4.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+patch_fixer/__init__.py,sha256=n5DDMr4jbO3epK3ybBvjDyRddTWlWamN6ao5BC7xHFo,65
+patch_fixer/cli.py,sha256=4zy02FsVrUrcQzsBwQ58PVfJXoG4OsOYKpk2JXGw1cY,3841
+patch_fixer/patch_fixer.py,sha256=YaArYeni8rFfFqILlytW7Bo9xz14SlsWGVjzHR_QqdI,28451
+patch_fixer/split.py,sha256=l0rHM6-ZBuB9Iv6Ng6rxqZH5eKfvk2t87j__nDu67kM,3869
+patch_fixer-0.4.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+patch_fixer-0.4.0.dist-info/METADATA,sha256=IAp5OWD110pKDSyzkDaj8rbLuX307Oo_CjJ93Ti-4-s,4907
+patch_fixer-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+patch_fixer-0.4.0.dist-info/entry_points.txt,sha256=ftc6dP6B1zJouSPeCCJLZtx-EEGVSrNEwy4YhtnEoxA,53
+patch_fixer-0.4.0.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
+patch_fixer-0.4.0.dist-info/RECORD,,

patch_fixer-0.3.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-patch_fixer/__init__.py,sha256=n5DDMr4jbO3epK3ybBvjDyRddTWlWamN6ao5BC7xHFo,65
-patch_fixer/cli.py,sha256=hgneS8DSCWBxv1l0u37n60FPGskAsDgodX9YxKgF-H0,3417
-patch_fixer/patch_fixer.py,sha256=GAavb15H5cEoNFgGlO5hIY7EOF88VCsjHcLrfyGW4_0,20587
-patch_fixer/split.py,sha256=l0rHM6-ZBuB9Iv6Ng6rxqZH5eKfvk2t87j__nDu67kM,3869
-patch_fixer-0.3.3.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-patch_fixer-0.3.3.dist-info/METADATA,sha256=URfv2ws8naMvx3t8xsqN5JyGBlC38EydFYPwgivTnvQ,4117
-patch_fixer-0.3.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-patch_fixer-0.3.3.dist-info/entry_points.txt,sha256=ftc6dP6B1zJouSPeCCJLZtx-EEGVSrNEwy4YhtnEoxA,53
-patch_fixer-0.3.3.dist-info/top_level.txt,sha256=yyp3KjFgExJsrFsS9ZBCnkhb05xg8hPYhB7ncdpTOv0,12
-patch_fixer-0.3.3.dist-info/RECORD,,