natural-pdf 0.2.3__py3-none-any.whl → 0.2.5__py3-none-any.whl

natural_pdf/vision/results.py

@@ -0,0 +1,146 @@
+"""Match results for visual similarity search"""
+
+from typing import TYPE_CHECKING, Any, Iterator, List, Optional, Tuple
+
+# Import Region directly as it's a base class
+from natural_pdf.elements.region import Region
+
+if TYPE_CHECKING:
+    from natural_pdf.core.page_collection import PageCollection
+    from natural_pdf.elements.element_collection import ElementCollection
+
+
+class Match(Region):
+    """A region that was found via visual similarity search"""
+
+    def __init__(self, page, bbox, confidence, source_example=None, metadata=None):
+        """
+        Initialize a Match object.
+
+        Args:
+            page: Page containing the match
+            bbox: Bounding box of the match
+            confidence: Similarity confidence (0-1)
+            source_example: The example/template that led to this match
+            metadata: Additional metadata about the match
+        """
+        super().__init__(page, bbox)
+        self.confidence = confidence
+        self.source_example = source_example
+        self.metadata = metadata or {}
+
+    @property
+    def pdf(self):
+        """Get the PDF containing this match"""
+        return self.page.pdf
+
+    def __repr__(self):
+        return f"<Match page={self.page.number} confidence={self.confidence:.2f} bbox={self.bbox}>"
+
+
+class MatchResults:
+    """Collection of Match objects with transformation methods"""
+
+    def __init__(self, matches: List[Match]):
+        """Initialize with list of Match objects"""
+        # Import here to avoid circular import
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        # Create a base ElementCollection
+        self._collection = ElementCollection(matches)
+        self._matches = matches
+
+    def __len__(self):
+        return len(self._matches)
+
+    def __iter__(self):
+        return iter(self._matches)
+
+    def __getitem__(self, key):
+        return self._matches[key]
+
+    def filter(self, filter_func) -> "MatchResults":
+        """Filter matches by a function"""
+        filtered = [m for m in self if filter_func(m)]
+        return MatchResults(filtered)
+
+    def filter_by_confidence(self, min_confidence: float) -> "MatchResults":
+        """Filter matches by minimum confidence"""
+        return self.filter(lambda m: m.confidence >= min_confidence)
+
+    def pages(self):
+        """Get unique pages containing matches"""
+        # Import here to avoid circular import
+        from natural_pdf.core.page_collection import PageCollection
+
+        # Get unique pages while preserving order
+        seen = set()
+        unique_pages = []
+        for match in self:
+            if match.page not in seen:
+                seen.add(match.page)
+                unique_pages.append(match.page)
+
+        # Attach matches to each page
+        for page in unique_pages:
+            page._matches = MatchResults([m for m in self if m.page == page])
+
+        return PageCollection(unique_pages)
+
+    def pdfs(self):
+        """Get unique PDFs containing matches"""
+        # Import here to avoid circular import
+        from natural_pdf.core.pdf_collection import PDFCollection
+
+        # Get unique PDFs while preserving order
+        seen = set()
+        unique_pdfs = []
+        for match in self:
+            if match.pdf not in seen:
+                seen.add(match.pdf)
+                unique_pdfs.append(match.pdf)
+
+        # Attach matches to each PDF
+        for pdf in unique_pdfs:
+            pdf._matches = MatchResults([m for m in self if m.pdf == pdf])
+
+        return PDFCollection(unique_pdfs)
+
+    def group_by_page(self) -> Iterator[Tuple[Any, "MatchResults"]]:
+        """Group matches by page"""
+        from itertools import groupby
+
+        # Sort by PDF filename and page number
+        sorted_matches = sorted(self, key=lambda m: (getattr(m.pdf, "filename", ""), m.page.number))
+
+        for page, matches in groupby(sorted_matches, key=lambda m: m.page):
+            yield page, MatchResults(list(matches))
+
+    def sort_by_confidence(self, descending: bool = True) -> "MatchResults":
+        """Sort matches by confidence score"""
+        sorted_matches = sorted(self, key=lambda m: m.confidence, reverse=descending)
+        return MatchResults(sorted_matches)
+
+    def regions(self):
+        """Get all matches as an ElementCollection of regions"""
+        # Import here to avoid circular import
+        from natural_pdf.elements.element_collection import ElementCollection
+
+        # Matches are already Region objects, so just wrap them
+        return ElementCollection(list(self))
+
+    def show(self, **kwargs):
+        """Show all matches using ElementCollection.show()"""
+        # Get regions and show them
+        return self.regions().show(**kwargs)
+
+    def __repr__(self):
+        if len(self) == 0:
+            return "<MatchResults: empty>"
+        elif len(self) == 1:
+            return f"<MatchResults: 1 match>"
+        else:
+            conf_range = (
+                f"{min(m.confidence for m in self):.2f}-{max(m.confidence for m in self):.2f}"
+            )
+            return f"<MatchResults: {len(self)} matches, confidence {conf_range}>"

natural_pdf/vision/similarity.py

@@ -0,0 +1,321 @@
+"""Visual similarity matching using perceptual hashing"""
+
+from dataclasses import dataclass
+from typing import Callable, List, Optional, Tuple, Union
+
+import numpy as np
+from PIL import Image
+from tqdm.auto import tqdm
+
+
+@dataclass
+class MatchCandidate:
+    """Candidate match during sliding window search"""
+
+    bbox: Tuple[float, float, float, float]
+    hash_value: int
+    confidence: float
+
+
+def compute_phash(image: Image.Image, hash_size: int = 8, blur_radius: float = 0) -> int:
+    """
+    Compute perceptual hash of an image using DCT.
+
+    Args:
+        image: PIL Image to hash
+        hash_size: Size of the hash (8 = 64 bit hash)
+        blur_radius: Optional blur to apply before hashing (makes more tolerant)
+
+    Returns:
+        Integer hash value
+    """
+    # Convert to grayscale
+    if image.mode != "L":
+        image = image.convert("L")
+
+    # Optional blur to reduce sensitivity to minor variations
+    if blur_radius > 0:
+        from PIL import ImageFilter
+
+        image = image.filter(ImageFilter.GaussianBlur(radius=blur_radius))
+
+    # Resize to 32x32 (4x the hash size for DCT)
+    highfreq_factor = 4
+    img_size = hash_size * highfreq_factor
+    image = image.resize((img_size, img_size), Image.Resampling.LANCZOS)
+
+    # Convert to numpy array
+    pixels = np.array(image, dtype=np.float32)
+
+    # Apply DCT
+    from scipy.fftpack import dct
+
+    dct_coef = dct(dct(pixels, axis=0), axis=1)
+
+    # Keep top-left 8x8 (low frequencies)
+    dct_low = dct_coef[:hash_size, :hash_size]
+
+    # Compute median excluding the DC component
+    dct_low_no_dc = dct_low.flatten()[1:]  # Skip first element (DC)
+    median = np.median(dct_low_no_dc)
+
+    # Create binary hash
+    diff = dct_low.flatten() > median
+
+    # Convert to integer
+    return sum(2**i for i, v in enumerate(diff) if v)
+
+
+def hamming_distance(hash1: int, hash2: int, hash_size: int = 64) -> int:
+    """Calculate Hamming distance between two hashes"""
+    # XOR and count set bits
+    xor = hash1 ^ hash2
+    return bin(xor).count("1")
+
+
+def hash_similarity(hash1: int, hash2: int, hash_size: int = 64) -> float:
+    """Calculate similarity score between two hashes (0-1)"""
+    distance = hamming_distance(hash1, hash2, hash_size)
+    return 1.0 - (distance / hash_size)
+
+
+class VisualMatcher:
+    """Handles visual similarity matching using perceptual hashing"""
+
+    def __init__(self, hash_size: int = 12):
+        self.hash_size = hash_size
+        self.hash_bits = hash_size * hash_size
+        self._cache = {}
+
+    def _get_search_scales(self, sizes: Optional[Union[float, Tuple, List]]) -> List[float]:
+        """
+        Convert various size input formats to a list of scales to search.
+
+        Args:
+            sizes: Can be:
+                - None: just 1.0
+                - float: ±percentage (e.g., 0.2 = 80%-120%)
+                - tuple(min, max): range with smart logarithmic steps
+                - tuple(min, max, step): explicit step size
+                - list: exact sizes to use
+
+        Returns:
+            List of scale factors to search
+        """
+        if sizes is None:
+            return [1.0]
+
+        # List of exact sizes
+        if isinstance(sizes, list):
+            return sorted(sizes)
+
+        # Single float: ±percentage
+        if isinstance(sizes, (int, float)):
+            if sizes <= 0:
+                return [1.0]
+            # Convert to min/max range
+            min_scale = max(0.1, 1.0 - sizes)
+            max_scale = 1.0 + sizes
+            # Use tuple logic below
+            sizes = (min_scale, max_scale)
+
+        # Tuple handling
+        if isinstance(sizes, tuple):
+            if len(sizes) == 2:
+                min_scale, max_scale = sizes
+                if min_scale >= max_scale:
+                    return [min_scale]
+
+                # Smart defaults with logarithmic spacing
+                # Calculate range ratio to determine number of steps
+                ratio = max_scale / min_scale
+
+                if ratio <= 1.5:  # Small range (e.g., 0.8-1.2)
+                    num_steps = 5
+                elif ratio <= 3.0:  # Medium range (e.g., 0.5-1.5)
+                    num_steps = 7
+                else:  # Large range (e.g., 0.5-2.0)
+                    num_steps = 9
+
+                # Generate logarithmically spaced scales
+                log_min = np.log(min_scale)
+                log_max = np.log(max_scale)
+                log_scales = np.linspace(log_min, log_max, num_steps)
+                scales = np.exp(log_scales).tolist()
+
+                # Ensure 1.0 is included if in range
+                if min_scale <= 1.0 <= max_scale and 1.0 not in scales:
+                    # Find closest scale and replace with 1.0
+                    closest_idx = np.argmin([abs(s - 1.0) for s in scales])
+                    scales[closest_idx] = 1.0
+
+                return scales
+
+            elif len(sizes) == 3:
+                # Explicit (min, max, step)
+                min_scale, max_scale, step = sizes
+                scales = []
+                current = min_scale
+                while current <= max_scale:
+                    scales.append(current)
+                    current += step
+                # Ensure max is included if close
+                if scales[-1] < max_scale and (max_scale - scales[-1]) < step * 0.1:
+                    scales[-1] = max_scale
+                return scales
+
+        raise ValueError(f"Invalid sizes format: {sizes}")
+
+    def find_matches_in_image(
+        self,
+        template: Image.Image,
+        target: Image.Image,
+        template_hash: Optional[int] = None,
+        confidence_threshold: float = 0.6,
+        step_factor: float = 0.1,
+        sizes: Optional[Union[float, Tuple, List]] = None,
+        show_progress: bool = True,
+        progress_callback: Optional[Callable[[], None]] = None,
+    ) -> List[MatchCandidate]:
+        """
+        Find all matches of template in target image using sliding window.
+
+        Args:
+            template: Template image to search for
+            target: Target image to search in
+            template_hash: Pre-computed hash of template (optional)
+            confidence_threshold: Minimum similarity score (0-1)
+            step_factor: Step size as fraction of template size
+            sizes: Size variations to search. Can be:
+                   - float: ±percentage (e.g., 0.2 = 80%-120%)
+                   - tuple(min, max): search range with smart logarithmic steps
+                   - tuple(min, max, step): explicit step size
+                   - list: exact sizes to try (e.g., [0.8, 1.0, 1.2])
+            show_progress: Show progress bar for sliding window search
+            progress_callback: Optional callback function to call for each window checked
+
+        Returns:
+            List of MatchCandidate objects
+        """
+        matches = []
+
+        # Compute template hash if not provided
+        if template_hash is None:
+            template_hash = compute_phash(template, self.hash_size)
+
+        template_w, template_h = template.size
+        target_w, target_h = target.size
+
+        # Determine scales to search
+        scales = self._get_search_scales(sizes)
+
+        # Calculate total iterations for progress bar
+        total_iterations = 0
+        if show_progress and not progress_callback:
+            for scale in scales:
+                scaled_w = int(template_w * scale)
+                scaled_h = int(template_h * scale)
+                if scaled_w <= target_w and scaled_h <= target_h:
+                    step_x = max(1, int(scaled_w * step_factor))
+                    step_y = max(1, int(scaled_h * step_factor))
+                    x_steps = len(range(0, target_w - scaled_w + 1, step_x))
+                    y_steps = len(range(0, target_h - scaled_h + 1, step_y))
+                    total_iterations += x_steps * y_steps
+
+        # Setup progress bar if needed (only if no callback provided)
+        progress_bar = None
+        if show_progress and not progress_callback and total_iterations > 0:
+            progress_bar = tqdm(total=total_iterations, desc="Scanning", unit="window", leave=False)
+
+        # Search at each scale
+        for scale in scales:
+            # Scale template size
+            scaled_w = int(template_w * scale)
+            scaled_h = int(template_h * scale)
+
+            if scaled_w > target_w or scaled_h > target_h:
+                continue
+
+            # Calculate step size
+            step_x = max(1, int(scaled_w * step_factor))
+            step_y = max(1, int(scaled_h * step_factor))
+
+            # Sliding window search
+            for y in range(0, target_h - scaled_h + 1, step_y):
+                for x in range(0, target_w - scaled_w + 1, step_x):
+                    # Extract window
+                    window = target.crop((x, y, x + scaled_w, y + scaled_h))
+
+                    # Resize to template size if scaled
+                    if scale != 1.0:
+                        window = window.resize((template_w, template_h), Image.Resampling.LANCZOS)
+
+                    # Compute hash and similarity
+                    window_hash = compute_phash(window, self.hash_size)
+                    similarity = hash_similarity(template_hash, window_hash, self.hash_bits)
+
+                    if similarity >= confidence_threshold:
+                        # Convert back to target image coordinates
+                        bbox = (x, y, x + scaled_w, y + scaled_h)
+                        matches.append(MatchCandidate(bbox, window_hash, similarity))
+
+                    # Update progress
+                    if progress_bar:
+                        progress_bar.update(1)
+                    elif progress_callback:
+                        progress_callback()
+
+        # Close progress bar
+        if progress_bar:
+            progress_bar.close()
+
+        # Remove overlapping matches (keep highest confidence)
+        return self._filter_overlapping_matches(matches)
+
+    def _filter_overlapping_matches(
+        self, matches: List[MatchCandidate], overlap_threshold: float = 0.5
+    ) -> List[MatchCandidate]:
+        """Remove overlapping matches, keeping the highest confidence ones"""
+        if not matches:
+            return matches
+
+        # Sort by confidence (highest first)
+        sorted_matches = sorted(matches, key=lambda m: m.confidence, reverse=True)
+        filtered = []
+
+        for candidate in sorted_matches:
+            # Check if this overlaps significantly with any already selected match
+            keep = True
+            for selected in filtered:
+                overlap = self._calculate_overlap(candidate.bbox, selected.bbox)
+                if overlap > overlap_threshold:
+                    keep = False
+                    break
+
+            if keep:
+                filtered.append(candidate)
+
+        return filtered
+
+    def _calculate_overlap(self, bbox1: Tuple, bbox2: Tuple) -> float:
+        """Calculate intersection over union (IoU) for two bboxes"""
+        x1_min, y1_min, x1_max, y1_max = bbox1
+        x2_min, y2_min, x2_max, y2_max = bbox2
+
+        # Calculate intersection
+        intersect_xmin = max(x1_min, x2_min)
+        intersect_ymin = max(y1_min, y2_min)
+        intersect_xmax = min(x1_max, x2_max)
+        intersect_ymax = min(y1_max, y2_max)
+
+        if intersect_xmax < intersect_xmin or intersect_ymax < intersect_ymin:
+            return 0.0
+
+        intersect_area = (intersect_xmax - intersect_xmin) * (intersect_ymax - intersect_ymin)
+
+        # Calculate union
+        area1 = (x1_max - x1_min) * (y1_max - y1_min)
+        area2 = (x2_max - x2_min) * (y2_max - y2_min)
+        union_area = area1 + area2 - intersect_area
+
+        return intersect_area / union_area if union_area > 0 else 0.0

{natural_pdf-0.2.3.dist-info → natural_pdf-0.2.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: natural-pdf
-Version: 0.2.3
+Version: 0.2.5
 Summary: A more intuitive interface for working with PDFs
 Author-email: Jonathan Soma <jonathan.soma@gmail.com>
 License-Expression: MIT

{natural_pdf-0.2.3.dist-info → natural_pdf-0.2.5.dist-info}/RECORD

@@ -2,7 +2,7 @@ natural_pdf/__init__.py,sha256=N4pR0LbuPEnUYFZqbdVqc_FGKldgwPQc1wjJhYKTBBM,3417
 natural_pdf/cli.py,sha256=SkPwhhMM-GhLsj3O1n1Agxz4KOxcZ08sj8hVQSFJB5c,4064
 natural_pdf/text_mixin.py,sha256=eFCiHj6Okcw3aum4955BepcI2NPRalkf9UFFVTc_H30,4012
 natural_pdf/analyzers/__init__.py,sha256=3XGoNq3OgiVkZP7tOdeP5XVUl7fDgyztdA8DlOcMLXg,1138
-natural_pdf/analyzers/guides.py,sha256=9FUbxk4XBOyktXgq9q5-bB949JFrzT1kBPikg2ENoIw,150032
+natural_pdf/analyzers/guides.py,sha256=mLWPPEwywo_FbU3gSoegiRlzxYmkHEo2c4DLX9krH9k,157691
 natural_pdf/analyzers/shape_detection_mixin.py,sha256=mgpyJ4jIulz9l9HCqThabJIsLSrXh9BB2AmLxUoHmw0,62584
 natural_pdf/analyzers/text_options.py,sha256=qEkDaYWla0rIM_gszEOsu52q7C_dAfV81P2HLJZM2sw,3333
 natural_pdf/analyzers/text_structure.py,sha256=3WWusi-BI0krUnJxB05DD6XmKj5qRNvQBqH7zOQGm1M,28451
@@ -25,26 +25,26 @@ natural_pdf/classification/mixin.py,sha256=CXygXXhe_qx1563SmIjiu4uSnZkxCkuRR4fGv
 natural_pdf/classification/results.py,sha256=5ha77CxK0GYwkBMJbvUBZkBjsL5GpOveIZDK9nO4j8I,3239
 natural_pdf/collections/mixins.py,sha256=Se2C5AcpP9B5E0d0pIrey6-f_P32tAXTK4M7666MNj0,5688
 natural_pdf/core/__init__.py,sha256=QC8H4M3KbXwMFiQORZ0pdPlzx1Ix6oKKQSS7Ib2KEaA,38
-natural_pdf/core/element_manager.py,sha256=DRZvntd99wjXy6KeDjCq5uRhjMftZop9QklOZqlUH8M,55349
+natural_pdf/core/element_manager.py,sha256=KPuKM7SstfErTkRnGq4vrgE0Tv8iazN13Jp7yAXGKso,55575
 natural_pdf/core/highlighting_service.py,sha256=7on8nErhi50CEH2L4XzGIZ6tIqZtMzmmFlp-2lmwnYE,68856
-natural_pdf/core/page.py,sha256=4-il2WPMVX4hNSgQ5P6yLc1-3jXfi73WCrpF9912ct4,142472
+natural_pdf/core/page.py,sha256=Q3hBvB9KFB8doeXY7YVQt3G1ULdBDfA-0BQD6YPN4oo,144640
 natural_pdf/core/page_collection.py,sha256=hEeXs_fzB73XZ8ZkHz2kIuSgBYcVYydvGMMdGuB1rvw,52486
 natural_pdf/core/page_groupby.py,sha256=550ME6kd-h-2u75oUIIIqTYsmh8VvdQO1nXXioL8J6A,7378
-natural_pdf/core/pdf.py,sha256=q54DyhXwAS_zAmsBd3PsCezu1wyQOYmGmB3iKfP8gAM,101884
-natural_pdf/core/pdf_collection.py,sha256=8tM0qVWS1L5Hwv5cXuZ2X8znAYOjKmlERX62bksDlJU,30144
-natural_pdf/core/render_spec.py,sha256=3GTfnlv8JKzePrruLq_dNr3HFeWMVcZT2fwWmJN44NI,14456
+natural_pdf/core/pdf.py,sha256=VslSn00So6157XfiYbrB9URpx5VlWyshQOt7upi9us4,104248
+natural_pdf/core/pdf_collection.py,sha256=s3ogu4CEHrHMTRqQMJUKJZ-9Ii8b_B9dWbVLTFj0s7g,34992
+natural_pdf/core/render_spec.py,sha256=rLicaS9EPyojpJcjy2Lzn5DLWQwjrFyDJyRo7jbjdGU,14505
 natural_pdf/describe/__init__.py,sha256=kIV7ORmWWB1SAur7nK2aAwR-wHqSedhKfUsaUl4hG0A,586
 natural_pdf/describe/base.py,sha256=Of9WVo9XuShXoeyJr0RN2CpLhF_CeiOjazl-or53RKU,18173
 natural_pdf/describe/elements.py,sha256=JicXC9SJmmasqxalpCXA47-kVwv-6JnR3Xiu778aNHM,12634
 natural_pdf/describe/mixin.py,sha256=rkX14aGrSz7Jvxx8Rbxv3eSfbO-_29DipwpstrV2pDQ,3109
 natural_pdf/describe/summary.py,sha256=cfT4ZQkeatCDAOwWPwhtEVXisNgk6E57fAXAnoRysSU,7645
 natural_pdf/elements/__init__.py,sha256=ICNikmLeIEuSYypz-KnkBn8xR1hR7rge4hsa1KLkyWY,42
-natural_pdf/elements/base.py,sha256=xXdNV1_gt4T_V_4m6qJDieWiysvJxUBhSEEAJzMOzqo,55094
+natural_pdf/elements/base.py,sha256=aj-eXOQQlhKv9lYeUlUs9aKNcUebtG_dqxURZHZVZ58,55509
 natural_pdf/elements/element_collection.py,sha256=slCUnOT04sNOTjSGgmhjcCKKPVPtdDPwU7PX1ebzGMw,101342
 natural_pdf/elements/image.py,sha256=zu-P2Y8fRoEXf6IeZU0EYRWsgZ6I_a5vy1FA3VXTGkQ,1424
 natural_pdf/elements/line.py,sha256=TFn7KXjPT_jUQyQyabU0F7XYU4dC-qadwodJMZF4DCU,3844
 natural_pdf/elements/rect.py,sha256=0lNkVkPkvbRbrFED856RXoUcTcDkeeOIs5xldKGAQT8,3324
-natural_pdf/elements/region.py,sha256=Onok5VzmF1CvMCa3UGLUszCuhL-CCGk_IgtSUDva-Cc,155314
+natural_pdf/elements/region.py,sha256=_NNBewHlyUHvA4g9kApilP6it0cn2IRlcGG4r993oUI,156660
 natural_pdf/elements/text.py,sha256=829uSJv9E-8cC6T6iR_Va7Xtv54pJoyRN78fq4NN1d4,20687
 natural_pdf/export/mixin.py,sha256=L1q3MIEFWuvie4j4_EmW7GT3NerbZ1as0XMUoqTS7gM,5083
 natural_pdf/exporters/__init__.py,sha256=QffoARekR6WzXEd05oxOytly4qPdBizuIF-SUkeFpig,643
@@ -87,7 +87,7 @@ natural_pdf/search/searchable_mixin.py,sha256=hqQ_AuID5eTGRCtKYdFLZ1zF35y73uk3x1
 natural_pdf/selectors/__init__.py,sha256=oZGeqSv53EqmIZOhcnawuaGGlRg1h79vArXuZCWKm4A,123
 natural_pdf/selectors/parser.py,sha256=pw0M8ICKPMOzZPzWpLsQMG_lnl8PewGIdIG3ciukabk,38877
 natural_pdf/tables/__init__.py,sha256=sCvCGbGsL6BiqlNxAYfVv003bIDLI11FmjHhaWfcU6w,104
-natural_pdf/tables/result.py,sha256=1pcelNZvOb6Anlwj08Z1XU-YK1ihlCsLpYMRA3Zc4JM,7242
+natural_pdf/tables/result.py,sha256=-8ctA-jCJYSHtlfAoqTvhUwO5zSP2BQxxetAjqEsNyg,8665
 natural_pdf/templates/__init__.py,sha256=jYBxzfi73vew0f6yhIh1MlRxw4F_TVN2hKQR0YXOFe0,20
 natural_pdf/utils/__init__.py,sha256=s3M8FggaK1P3EBYn6R_-HgSDjNc9C73gyKe1hihtNWg,43
 natural_pdf/utils/bidi_mirror.py,sha256=jJEES0xDrMfo5Me8kHMxHv4COS51PitnYi2EvKv3HCE,1151
@@ -100,9 +100,13 @@ natural_pdf/utils/packaging.py,sha256=TM0jafwS5yVbTGC-RMi4TyWunf9cUUo9h5J6rMzkT-
 natural_pdf/utils/reading_order.py,sha256=u7XyVZdKMPMK0CL1C7xFogKnZ92b0JKT068KFjQWe18,7437
 natural_pdf/utils/text_extraction.py,sha256=CCwPTmMoTgtQt2P00X_ADIf6ZGNfxvjCO9FO0_HqG40,13900
 natural_pdf/utils/visualization.py,sha256=zhZEHgYnZFuX7YxTHXF8Y3D97uHp2beTKMaC-JkCFwk,22364
+natural_pdf/vision/__init__.py,sha256=RymMY-3WLQBlOZ4Dx4MmL9UH6I65hNjkwUJ7ymO5JfM,287
+natural_pdf/vision/mixin.py,sha256=OJwBABr74TWxP5seTKUmGj5zE9mWsBP_UKWU-Pr8V9A,8720
+natural_pdf/vision/results.py,sha256=F2zXG3MVZIpOUvPkJHotOq6-9rFz68BaO_8pnSndlOs,5119
+natural_pdf/vision/similarity.py,sha256=YH8legN-t9uf1b_XULi4JLNDaRfPNKQwU1FZ4Qu08jY,11740
 natural_pdf/widgets/__init__.py,sha256=QTVaUmsw__FCweFYZebwPssQxxUFUMd0wpm_cUbGZJY,181
 natural_pdf/widgets/viewer.py,sha256=KW3JogdR2TMg2ECUMYp8hwd060hfg8EsYBWxb5IEzBY,24942
-natural_pdf-0.2.3.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.2.5.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
 optimization/memory_comparison.py,sha256=0i_foFSRmppj-fY069qjwH36s_zkx-1L2ASAAlepWzA,6541
 optimization/pdf_analyzer.py,sha256=HjrmTgu2qchxPeDckc5kjgxppGwd40UESrYS9Myj7pY,19352
 optimization/performance_analysis.py,sha256=JBXnR9hc7Ix7YCnt3EJPSpsyqIUgKsc7GEffQ_TDCBk,13033
@@ -119,8 +123,8 @@ tools/bad_pdf_eval/llm_enrich.py,sha256=mCh4KGi1HmIkzGjj5rrHz1Osd7sEX1IZ_FW08H1t
 tools/bad_pdf_eval/llm_enrich_with_retry.py,sha256=XUtPF1hUvqd3frDXT0wDTXoonuAivhjM5vgFdZ-tm0A,9373
 tools/bad_pdf_eval/reporter.py,sha256=e1g__mkSB4q02p3mGWOwMhvFs7F2HJosNBxup0-LkyU,400
 tools/bad_pdf_eval/utils.py,sha256=hR95XQ7qf7Cu6BdyX0L7ggGVx-ah5sK0jHWblTJUUic,4896
-natural_pdf-0.2.3.dist-info/METADATA,sha256=lyx6Cx1xPGhy-p1m0wRfTvv4zSJ4ZJnNo7DeGQZ99yU,6959
-natural_pdf-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.2.3.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.2.3.dist-info/top_level.txt,sha256=80t0F2ZeX4vN4Ke5iTflcOk_PN_0USn33ha3X6X86Ik,36
-natural_pdf-0.2.3.dist-info/RECORD,,
+natural_pdf-0.2.5.dist-info/METADATA,sha256=H9nhjh1zRBmz2vUTe_j6FT-Zvn1sgoWT0nyoZG5GTYg,6959
+natural_pdf-0.2.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.2.5.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.2.5.dist-info/top_level.txt,sha256=80t0F2ZeX4vN4Ke5iTflcOk_PN_0USn33ha3X6X86Ik,36
+natural_pdf-0.2.5.dist-info/RECORD,,