bram-patience-diff 1.0.0__tar.gz

bram_patience_diff-1.0.0/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2009--2026 Jane Street Group, LLC <opensource-contacts@janestreet.com>
+
+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.

bram_patience_diff-1.0.0/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: bram-patience-diff
+Version: 1.0.0
+Summary: Patience Diff Algorithm - An implementation of Bram Cohen's diff algorithm
+Home-page: https://github.com/joery0x3b800001/patience_diff
+Author: Shaun Joe
+Author-email: shaunjoeroy1234@gmail.com
+License: GPLv2+
+Project-URL: Bug Tracker, https://github.com/joery0x3b800001/patience_diff/issues
+Project-URL: Source, https://github.com/joery0x3b800001/patience_diff
+Keywords: diff algorithm patience sorting sequence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# Patience Diff
+
+A complete Python port of Bram Cohen's algorithm for computing efficient differences.
+
+## Features
+
+- Patience Sorting Algorithm: O(n log n)
+- Semantic Cleanup: Removes spurious matches
+- Multiple Output Formats: Blocks, hunks with context
+- Myers Fallback: Simple diff for edge cases
+- Type Hints: Full annotations for IDE support
+- Well Tested: Comprehensive test suite
+
+## Quick Start
+
+```bash
+make install  # Install in dev mode
+make test     # Run tests
+```
+
+## License
+
+GNU General Public License v2 or later
+
+Original algorithm and OCaml implementation by Bram Cohen  
+Copyright (C) 2005, 2006 Canonical Ltd  
+Python port by Shaun Joe
+
+
+## API Reference
+
+### Core Functions
+
+- `get_matching_blocks(transform, prev_array, next_array, big_enough=1)` - Find matching blocks
+- `get_hunks(transform, prev_array, next_array, context=-1, big_enough=1)` - Generate hunks  
+- `matches(prev_array, next_array)` - Get matching index pairs
+- `match_ratio(prev_array, next_array)` - Calculate similarity ratio
+
+### Data Types
+
+- `Hunk` - Contiguous diff region with ranges
+- `MatchingBlock` - Matching subsequence (prev_start, next_start, length)
+- Range types: `Same`, `Prev`, `Next`, `Replace`
+
+
+## Project Structure
+
+```
+src/                      # Python package (11 modules)
+├── patience_diff.py      # Core algorithm (700+ lines)
+├── plain_diff.py         # Myers fallback
+├── hunk.py               # Hunk data structures
+├── hunks.py              # Hunk utilities
+├── matching_block.py     # Matching block type
+├── range.py              # Range types
+├── move_id.py            # Move identifiers
+├── move_kind.py          # Move classification
+├── patience_diff_intf.py # Interface definitions
+├── patience_diff_lib.py  # Library exports
+└── __init__.py           # Package initialization
+
+test/                     # Test suite
+├── test_limit_context.py
+├── test_merge_diff.py
+└── test_plain_diff_cutoff.py
+
+Makefile                  # Build automation
+setup.py                  # Package setup
+pyproject.toml            # Build configuration
+README.md
+```
+
+
+## Testing
+
+All tests passing:
+
+```bash
+$ make test
+test/test_limit_context.py PASSED
+test/test_merge_diff.py PASSED
+test/test_plain_diff_cutoff.py PASSED
+
+============================  3 passed  ============================
+```
+
+
+## Algorithm
+
+The Patience Diff algorithm works in several steps:
+
+1. Identify unique elements (appearing exactly once in both sequences)
+2. Build longest increasing subsequence (LIS) of unique matches using patience sorting
+3. Recursively find matches in gaps between LIS elements
+4. Remove spurious small matches ("semantic cleanup")
+5. Merge adjacent blocks separated by identical elements
+6. Convert matching blocks to hunks with Same/Prev/Next/Replace ranges
+
+
+## References
+
+- http://bazaar-vcs.org - Original implementation
+- Eugene W. Myers: "An O(ND) Difference Algorithm and Its Variations"
+

bram_patience_diff-1.0.0/README.md

@@ -0,0 +1,104 @@
+# Patience Diff
+
+A complete Python port of Bram Cohen's algorithm for computing efficient differences.
+
+## Features
+
+- Patience Sorting Algorithm: O(n log n)
+- Semantic Cleanup: Removes spurious matches
+- Multiple Output Formats: Blocks, hunks with context
+- Myers Fallback: Simple diff for edge cases
+- Type Hints: Full annotations for IDE support
+- Well Tested: Comprehensive test suite
+
+## Quick Start
+
+```bash
+make install  # Install in dev mode
+make test     # Run tests
+```
+
+## License
+
+GNU General Public License v2 or later
+
+Original algorithm and OCaml implementation by Bram Cohen  
+Copyright (C) 2005, 2006 Canonical Ltd  
+Python port by Shaun Joe
+
+
+## API Reference
+
+### Core Functions
+
+- `get_matching_blocks(transform, prev_array, next_array, big_enough=1)` - Find matching blocks
+- `get_hunks(transform, prev_array, next_array, context=-1, big_enough=1)` - Generate hunks  
+- `matches(prev_array, next_array)` - Get matching index pairs
+- `match_ratio(prev_array, next_array)` - Calculate similarity ratio
+
+### Data Types
+
+- `Hunk` - Contiguous diff region with ranges
+- `MatchingBlock` - Matching subsequence (prev_start, next_start, length)
+- Range types: `Same`, `Prev`, `Next`, `Replace`
+
+
+## Project Structure
+
+```
+src/                      # Python package (11 modules)
+├── patience_diff.py      # Core algorithm (700+ lines)
+├── plain_diff.py         # Myers fallback
+├── hunk.py               # Hunk data structures
+├── hunks.py              # Hunk utilities
+├── matching_block.py     # Matching block type
+├── range.py              # Range types
+├── move_id.py            # Move identifiers
+├── move_kind.py          # Move classification
+├── patience_diff_intf.py # Interface definitions
+├── patience_diff_lib.py  # Library exports
+└── __init__.py           # Package initialization
+
+test/                     # Test suite
+├── test_limit_context.py
+├── test_merge_diff.py
+└── test_plain_diff_cutoff.py
+
+Makefile                  # Build automation
+setup.py                  # Package setup
+pyproject.toml            # Build configuration
+README.md
+```
+
+
+## Testing
+
+All tests passing:
+
+```bash
+$ make test
+test/test_limit_context.py PASSED
+test/test_merge_diff.py PASSED
+test/test_plain_diff_cutoff.py PASSED
+
+============================  3 passed  ============================
+```
+
+
+## Algorithm
+
+The Patience Diff algorithm works in several steps:
+
+1. Identify unique elements (appearing exactly once in both sequences)
+2. Build longest increasing subsequence (LIS) of unique matches using patience sorting
+3. Recursively find matches in gaps between LIS elements
+4. Remove spurious small matches ("semantic cleanup")
+5. Merge adjacent blocks separated by identical elements
+6. Convert matching blocks to hunks with Same/Prev/Next/Replace ranges
+
+
+## References
+
+- http://bazaar-vcs.org - Original implementation
+- Eugene W. Myers: "An O(ND) Difference Algorithm and Its Variations"
+

bram_patience_diff-1.0.0/bram_patience_diff.egg-info/PKG-INFO

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: bram-patience-diff
+Version: 1.0.0
+Summary: Patience Diff Algorithm - An implementation of Bram Cohen's diff algorithm
+Home-page: https://github.com/joery0x3b800001/patience_diff
+Author: Shaun Joe
+Author-email: shaunjoeroy1234@gmail.com
+License: GPLv2+
+Project-URL: Bug Tracker, https://github.com/joery0x3b800001/patience_diff/issues
+Project-URL: Source, https://github.com/joery0x3b800001/patience_diff
+Keywords: diff algorithm patience sorting sequence
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-python
+Dynamic: summary
+
+# Patience Diff
+
+A complete Python port of Bram Cohen's algorithm for computing efficient differences.
+
+## Features
+
+- Patience Sorting Algorithm: O(n log n)
+- Semantic Cleanup: Removes spurious matches
+- Multiple Output Formats: Blocks, hunks with context
+- Myers Fallback: Simple diff for edge cases
+- Type Hints: Full annotations for IDE support
+- Well Tested: Comprehensive test suite
+
+## Quick Start
+
+```bash
+make install  # Install in dev mode
+make test     # Run tests
+```
+
+## License
+
+GNU General Public License v2 or later
+
+Original algorithm and OCaml implementation by Bram Cohen  
+Copyright (C) 2005, 2006 Canonical Ltd  
+Python port by Shaun Joe
+
+
+## API Reference
+
+### Core Functions
+
+- `get_matching_blocks(transform, prev_array, next_array, big_enough=1)` - Find matching blocks
+- `get_hunks(transform, prev_array, next_array, context=-1, big_enough=1)` - Generate hunks  
+- `matches(prev_array, next_array)` - Get matching index pairs
+- `match_ratio(prev_array, next_array)` - Calculate similarity ratio
+
+### Data Types
+
+- `Hunk` - Contiguous diff region with ranges
+- `MatchingBlock` - Matching subsequence (prev_start, next_start, length)
+- Range types: `Same`, `Prev`, `Next`, `Replace`
+
+
+## Project Structure
+
+```
+src/                      # Python package (11 modules)
+├── patience_diff.py      # Core algorithm (700+ lines)
+├── plain_diff.py         # Myers fallback
+├── hunk.py               # Hunk data structures
+├── hunks.py              # Hunk utilities
+├── matching_block.py     # Matching block type
+├── range.py              # Range types
+├── move_id.py            # Move identifiers
+├── move_kind.py          # Move classification
+├── patience_diff_intf.py # Interface definitions
+├── patience_diff_lib.py  # Library exports
+└── __init__.py           # Package initialization
+
+test/                     # Test suite
+├── test_limit_context.py
+├── test_merge_diff.py
+└── test_plain_diff_cutoff.py
+
+Makefile                  # Build automation
+setup.py                  # Package setup
+pyproject.toml            # Build configuration
+README.md
+```
+
+
+## Testing
+
+All tests passing:
+
+```bash
+$ make test
+test/test_limit_context.py PASSED
+test/test_merge_diff.py PASSED
+test/test_plain_diff_cutoff.py PASSED
+
+============================  3 passed  ============================
+```
+
+
+## Algorithm
+
+The Patience Diff algorithm works in several steps:
+
+1. Identify unique elements (appearing exactly once in both sequences)
+2. Build longest increasing subsequence (LIS) of unique matches using patience sorting
+3. Recursively find matches in gaps between LIS elements
+4. Remove spurious small matches ("semantic cleanup")
+5. Merge adjacent blocks separated by identical elements
+6. Convert matching blocks to hunks with Same/Prev/Next/Replace ranges
+
+
+## References
+
+- http://bazaar-vcs.org - Original implementation
+- Eugene W. Myers: "An O(ND) Difference Algorithm and Its Variations"
+

bram_patience_diff-1.0.0/bram_patience_diff.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE.md
+README.md
+pyproject.toml
+setup.py
+bram_patience_diff.egg-info/PKG-INFO
+bram_patience_diff.egg-info/SOURCES.txt
+bram_patience_diff.egg-info/dependency_links.txt
+bram_patience_diff.egg-info/top_level.txt
+src/__init__.py
+src/hunk.py
+src/hunks.py
+src/matching_block.py
+src/move_id.py
+src/move_kind.py
+src/patience_diff.py
+src/patience_diff_intf.py
+src/patience_diff_lib.py
+src/plain_diff.py
+src/range.py
+test/__init__.py
+test/test_limit_context.py
+test/test_merge_diff.py
+test/test_patience_diff_lib.py
+test/test_plain_diff_cutoff.py

bram_patience_diff-1.0.0/bram_patience_diff.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

bram_patience_diff-1.0.0/bram_patience_diff.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+src
+test

bram_patience_diff-1.0.0/pyproject.toml

@@ -0,0 +1,7 @@
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.pytest.ini_options]
+testpaths = ["test"]
+python_files = ["test_*.py"]

bram_patience_diff-1.0.0/setup.cfg

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

bram_patience_diff-1.0.0/setup.py

@@ -0,0 +1,37 @@
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+setup(
+    name='bram-patience-diff',
+    version='1.0.0',
+    author='Shaun Joe',
+    author_email='shaunjoeroy1234@gmail.com',
+    description='Patience Diff Algorithm - An implementation of Bram Cohen\'s diff algorithm',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url='https://github.com/joery0x3b800001/patience_diff',
+    project_urls={
+        'Bug Tracker': 'https://github.com/joery0x3b800001/patience_diff/issues',
+        'Source': 'https://github.com/joery0x3b800001/patience_diff',
+    },
+    classifiers=[
+        'Development Status :: 4 - Beta',
+        'Intended Audience :: Developers',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'Topic :: Utilities',
+        'License :: OSI Approved :: GNU General Public License v2 or later (GPLv2+)',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.7',
+        'Programming Language :: Python :: 3.8',
+        'Programming Language :: Python :: 3.9',
+        'Programming Language :: Python :: 3.10',
+        'Programming Language :: Python :: 3.11',
+    ],
+    packages=find_packages(),
+    python_requires='>=3.7',
+    keywords='diff algorithm patience sorting sequence',
+    license='GPLv2+',
+)

bram_patience_diff-1.0.0/src/__init__.py

@@ -0,0 +1,81 @@
+"""
+Patience Diff - A Python port of the OCaml Patience Diff library.
+
+This is a comprehensive port of Bram Cohen's patience diff algorithm, as found in the Bazaar 1.14.1
+source code, available at http://bazaar-vcs.org.
+
+Copyright (C) 2005 Bram Cohen, Copyright (C) 2005, 2006 Canonical Ltd
+Licensed under GNU General Public License v2 or later.
+"""
+
+__version__ = "1.0.0"
+
+# Import all public modules for convenience
+from . import (
+    hunk,
+    hunks,
+    matching_block,
+    move_id,
+    move_kind,
+    patience_diff,
+    plain_diff,
+    range,
+)
+
+# Export commonly used classes and functions
+from .hunk import Hunk
+from .hunks import Hunks
+from .matching_block import MatchingBlock
+from .move_id import MoveId
+from .move_kind import Move, WithinMove
+from .range import Same, Prev, Next, Replace, Unified, Range
+from .patience_diff import (
+    get_matching_blocks,
+    get_hunks,
+    matches,
+    match_ratio,
+)
+
+# Create module-level exports similar to OCaml
+class PatienceDiff:
+    """Patience Diff algorithm module."""
+    get_matching_blocks = staticmethod(patience_diff.get_matching_blocks)
+    get_hunks = staticmethod(patience_diff.get_hunks)
+    matches = staticmethod(patience_diff.matches)
+    match_ratio = staticmethod(patience_diff.match_ratio)
+
+class PlainDiff:
+    """Plain (Myers) diff algorithm module."""
+    get_matching_blocks = staticmethod(plain_diff.get_matching_blocks)
+    get_hunks = staticmethod(plain_diff.get_hunks)
+    matches = staticmethod(plain_diff.matches)
+    match_ratio = staticmethod(plain_diff.match_ratio)
+
+__all__ = [
+    'hunk',
+    'hunks',
+    'matching_block',
+    'move_id',
+    'move_kind',
+    'patience_diff',
+    'plain_diff',
+    'range',
+    'Hunk',
+    'Hunks',
+    'MatchingBlock',
+    'MoveId',
+    'Move',
+    'WithinMove',
+    'Same',
+    'Prev',
+    'Next',
+    'Replace',
+    'Unified',
+    'Range',
+    'get_matching_blocks',
+    'get_hunks',
+    'matches',
+    'match_ratio',
+    'PatienceDiff',
+    'PlainDiff',
+]

bram_patience_diff-1.0.0/src/hunk.py

@@ -0,0 +1,123 @@
+"""Hunk dataclass for representing chunks of differences."""
+
+from dataclasses import dataclass, field
+from typing import List
+
+
+def _get_same_class():
+    """Lazy import to avoid circular imports."""
+    try:
+        from .range import Same
+    except ImportError:
+        from range import Same
+    return Same
+
+
+@dataclass
+class Hunk:
+    """A hunk represents a contiguous region of changes in a diff."""
+    prev_start: int
+    prev_size: int
+    next_start: int
+    next_size: int
+    ranges: List = field(default_factory=list)
+    
+    def all_same(self):
+        """Check if all ranges in this hunk are identical."""
+        Same = _get_same_class()
+        return all(isinstance(r, Same) for r in self.ranges)
+    
+    @staticmethod
+    def limit_infinite_context_hunk_to_context(hunk: 'Hunk', context: int) -> List['Hunk']:
+        """Split a hunk with unlimited context to one with limited context.
+        
+        Removes large Same ranges from the middle, keeping only 'context' lines
+        of context around changes.
+        """
+        if context < 0:
+            return [hunk]
+        
+        Same = _get_same_class()
+        
+        ranges = hunk.ranges
+        hunks_list = []
+        curr_ranges = []
+        prev_start = hunk.prev_start
+        next_start = hunk.next_start
+        
+        def finalize_hunk():
+            if curr_ranges:
+                h = Hunk(prev_start, prev_start, next_start, next_start, list(reversed(curr_ranges)))
+                hunks_list.append(h)
+                curr_ranges.clear()
+            return prev_start, next_start
+        
+        i = 0
+        while i < len(ranges):
+            r = ranges[i]
+            
+            if isinstance(r, Same):
+                size = len(r.items)
+                
+                if i == len(ranges) - 1:  # Last range
+                    # Crop to context
+                    keep = min(size, context)
+                    if keep > 0:
+                        cropped_items = r.items[:keep]
+                        curr_ranges.append(Same(cropped_items))
+                        prev_start += keep
+                        next_start += keep
+                    
+                    # Finalize
+                    finalize_hunk()
+                
+                elif size > context * 2:
+                    # This Same is large, split it
+                    # Keep first context
+                    first_items = r.items[:context]
+                    if first_items:
+                        curr_ranges.append(Same(first_items))
+                        prev_start += context
+                        next_start += context
+                    
+                    # Finalize current hunk
+                    finalize_hunk()
+                    
+                    # Advance by trimmed amount
+                    prev_start += size - context
+                    next_start += size - context
+                    
+                    # Keep last context for next hunk
+                    last_items = r.items[-context:]
+                    if last_items:
+                        curr_ranges.append(Same(last_items))
+                
+                else:
+                    # Keep entire Same range as context
+                    curr_ranges.append(r)
+                    prev_start += size
+                    next_start += size
+            
+            else:
+                # Non-Same range
+                if hasattr(r, 'items') and not isinstance(r, Same):
+                    # Prev or Next
+                    size = len(r.items)
+                    if hasattr(r, 'lines'):  # For backward compat
+                        size = len(r.lines)
+                    prev_start += size if hasattr(r, 'prev_items') else 0
+                    next_start += size if hasattr(r, 'next_items') else 0
+                elif hasattr(r, 'prev_items'):
+                    # Replace
+                    prev_start += len(r.prev_items)
+                    next_start += len(r.next_items)
+                
+                curr_ranges.append(r)
+            
+            i += 1
+        
+        # Finalize last hunk if needed
+        if curr_ranges:
+            finalize_hunk()
+        
+        return hunks_list