natural-pdf 0.2.16__py3-none-any.whl → 0.2.17__py3-none-any.whl

natural_pdf/utils/sections.py

@@ -0,0 +1,346 @@
+"""Centralized utilities for section extraction to avoid code duplication.
+
+This module provides the core logic for get_sections() and get_section_between()
+functionality that's used across Page, PDF, Region, and Flow classes.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from natural_pdf.core.page import Page
+    from natural_pdf.elements.base import Element
+    from natural_pdf.elements.region import Region
+
+logger = logging.getLogger(__name__)
+
+
+def calculate_section_bounds(
+    start_element: "Element",
+    end_element: "Element",
+    include_boundaries: str,
+    orientation: str,
+    parent_bounds: Tuple[float, float, float, float],
+) -> Tuple[float, float, float, float]:
+    """
+    Calculate the bounding box for a section between two elements.
+
+    This centralizes the logic for determining section boundaries based on
+    the include_boundaries parameter and orientation.
+
+    Args:
+        start_element: Element marking the start of the section
+        end_element: Element marking the end of the section
+        include_boundaries: How to include boundary elements: 'start', 'end', 'both', or 'none'
+        orientation: 'vertical' or 'horizontal' - determines section direction
+        parent_bounds: The bounding box (x0, top, x1, bottom) of the parent region
+
+    Returns:
+        Tuple of (x0, top, x1, bottom) representing the section bounds
+    """
+    parent_x0, parent_top, parent_x1, parent_bottom = parent_bounds
+
+    if orientation == "vertical":
+        # Use full width of the parent region for vertical sections
+        x0 = parent_x0
+        x1 = parent_x1
+
+        # Determine vertical boundaries based on include_boundaries
+        if include_boundaries == "both":
+            # Include both boundary elements
+            top = start_element.top
+            bottom = end_element.bottom
+        elif include_boundaries == "start":
+            # Include start element, exclude end element
+            top = start_element.top
+            bottom = end_element.top  # Stop at the top of end element
+        elif include_boundaries == "end":
+            # Exclude start element, include end element
+            top = start_element.bottom  # Start at the bottom of start element
+            bottom = end_element.bottom
+        else:  # "none"
+            # Exclude both boundary elements
+            top = start_element.bottom  # Start at the bottom of start element
+            bottom = end_element.top  # Stop at the top of end element
+
+    else:  # horizontal
+        # Use full height of the parent region for horizontal sections
+        top = parent_top
+        bottom = parent_bottom
+
+        # Determine horizontal boundaries based on include_boundaries
+        if include_boundaries == "both":
+            # Include both boundary elements
+            x0 = start_element.x0
+            x1 = end_element.x1
+        elif include_boundaries == "start":
+            # Include start element, exclude end element
+            x0 = start_element.x0
+            x1 = end_element.x0  # Stop at the left of end element
+        elif include_boundaries == "end":
+            # Exclude start element, include end element
+            x0 = start_element.x1  # Start at the right of start element
+            x1 = end_element.x1
+        else:  # "none"
+            # Exclude both boundary elements
+            x0 = start_element.x1  # Start at the right of start element
+            x1 = end_element.x0  # Stop at the left of end element
+
+    return (x0, top, x1, bottom)
+
+
+def validate_section_bounds(bounds: Tuple[float, float, float, float], orientation: str) -> bool:
+    """
+    Validate that section bounds are valid (not inverted).
+
+    Args:
+        bounds: The bounding box (x0, top, x1, bottom) to validate
+        orientation: 'vertical' or 'horizontal' - determines which dimension to check
+
+    Returns:
+        True if bounds are valid, False otherwise
+    """
+    x0, top, x1, bottom = bounds
+
+    if orientation == "vertical":
+        if top >= bottom:
+            logger.debug(f"Invalid vertical section boundaries: top={top} >= bottom={bottom}")
+            return False
+    else:  # horizontal
+        if x0 >= x1:
+            logger.debug(f"Invalid horizontal section boundaries: x0={x0} >= x1={x1}")
+            return False
+
+    return True
+
+
+def pair_boundary_elements(
+    start_elements: List["Element"],
+    end_elements: Optional[List["Element"]],
+    orientation: str = "vertical",
+) -> List[Tuple["Element", Optional["Element"]]]:
+    """
+    Pair up start and end boundary elements for section extraction.
+
+    This implements the logic for matching start elements with their corresponding
+    end elements, handling cases where end_elements is None or has different length.
+
+    Args:
+        start_elements: List of elements marking section starts
+        end_elements: Optional list of elements marking section ends
+        orientation: 'vertical' or 'horizontal' - affects element ordering
+
+    Returns:
+        List of (start_element, end_element) tuples
+    """
+    if not start_elements:
+        return []
+
+    # Sort elements by position
+    if orientation == "vertical":
+        start_elements = sorted(start_elements, key=lambda e: (e.top, e.x0))
+        if end_elements:
+            end_elements = sorted(end_elements, key=lambda e: (e.top, e.x0))
+    else:
+        start_elements = sorted(start_elements, key=lambda e: (e.x0, e.top))
+        if end_elements:
+            end_elements = sorted(end_elements, key=lambda e: (e.x0, e.top))
+
+    pairs = []
+
+    if not end_elements:
+        # No end elements - pair each start with the next start
+        for i in range(len(start_elements) - 1):
+            pairs.append((start_elements[i], start_elements[i + 1]))
+        # Last element has no pair unless we want to go to end of container
+        pairs.append((start_elements[-1], None))
+    else:
+        # Match each start with the next end that comes after it
+        used_ends = set()
+
+        for start in start_elements:
+            # Find the first unused end element that comes after this start
+            matching_end = None
+
+            for end in end_elements:
+                if end in used_ends:
+                    continue
+
+                # Check if end comes after start
+                if orientation == "vertical":
+                    if end.top > start.bottom or (end.top == start.bottom and end.x0 >= start.x0):
+                        matching_end = end
+                        break
+                else:  # horizontal
+                    if end.x0 > start.x1 or (end.x0 == start.x1 and end.top >= start.top):
+                        matching_end = end
+                        break
+
+            if matching_end:
+                pairs.append((start, matching_end))
+                used_ends.add(matching_end)
+            else:
+                # No matching end found
+                pairs.append((start, None))
+
+    return pairs
+
+
+def process_selector_to_elements(
+    selector_or_elements: Union[str, List["Element"], "Element", None],
+    search_context: Any,  # Can be Page, Region, Flow, etc.
+    find_method_name: str = "find_all",
+) -> List["Element"]:
+    """
+    Process a selector string or element list into a normalized list of elements.
+
+    Args:
+        selector_or_elements: Selector string, element, list of elements, or None
+        search_context: Object with find_all method (Page, Region, etc.)
+        find_method_name: Name of the method to call for searching (default: "find_all")
+
+    Returns:
+        List of elements (empty list if None or no matches)
+    """
+    if selector_or_elements is None:
+        return []
+
+    if isinstance(selector_or_elements, str):
+        # It's a selector string - search for matching elements
+        if hasattr(search_context, find_method_name):
+            result = getattr(search_context, find_method_name)(selector_or_elements)
+            if hasattr(result, "elements"):
+                return result.elements
+            elif isinstance(result, list):
+                return result
+            else:
+                return []
+        else:
+            logger.warning(f"Search context {type(search_context)} lacks {find_method_name} method")
+            return []
+
+    # Handle single element
+    if hasattr(selector_or_elements, "bbox"):  # Duck typing for Element
+        return [selector_or_elements]
+
+    # Handle ElementCollection or similar
+    if hasattr(selector_or_elements, "elements"):
+        return selector_or_elements.elements
+
+    # Handle list/iterable
+    if hasattr(selector_or_elements, "__iter__"):
+        return list(selector_or_elements)
+
+    return []
+
+
+def extract_sections_from_region(
+    region: "Region",
+    start_elements: Union[str, List["Element"], None],
+    end_elements: Union[str, List["Element"], None] = None,
+    include_boundaries: str = "both",
+    orientation: str = "vertical",
+    get_section_between_func: Optional[Any] = None,
+) -> List["Region"]:
+    """
+    Core implementation of get_sections() that can be reused across classes.
+
+    This implements the full logic for extracting multiple sections from a region
+    based on start/end boundary elements.
+
+    Args:
+        region: The region to extract sections from
+        start_elements: Elements or selector marking section starts
+        end_elements: Optional elements or selector marking section ends
+        include_boundaries: How to include boundary elements
+        orientation: Section orientation ('vertical' or 'horizontal')
+        get_section_between_func: Optional custom function to create sections
+
+    Returns:
+        List of Region objects representing the sections
+    """
+    # Process selectors to get element lists
+    start_elements = process_selector_to_elements(start_elements, region)
+    end_elements = process_selector_to_elements(end_elements, region) if end_elements else []
+
+    # Validate inputs
+    if not start_elements:
+        logger.debug("No start elements found for section extraction")
+        return []
+
+    # Get all elements in the region and sort by position
+    all_elements = region.get_elements()
+    if not all_elements:
+        return []
+
+    # Sort elements based on orientation
+    if orientation == "vertical":
+        all_elements.sort(key=lambda e: (e.top, e.x0))
+    else:
+        all_elements.sort(key=lambda e: (e.x0, e.top))
+
+    # Create element index map
+    element_to_index = {el: i for i, el in enumerate(all_elements)}
+
+    # Build boundary list with indices
+    boundaries = []
+
+    # Add start boundaries
+    for elem in start_elements:
+        idx = element_to_index.get(elem)
+        if idx is not None:
+            boundaries.append({"index": idx, "element": elem, "type": "start"})
+
+    # Add end boundaries
+    for elem in end_elements:
+        idx = element_to_index.get(elem)
+        if idx is not None:
+            boundaries.append({"index": idx, "element": elem, "type": "end"})
+
+    # Sort boundaries by document order
+    boundaries.sort(key=lambda x: x["index"])
+
+    # Generate sections
+    sections = []
+    current_start = None
+    section_func = get_section_between_func or region.get_section_between
+
+    for boundary in boundaries:
+        if boundary["type"] == "start":
+            if current_start is None:
+                # Start a new section
+                current_start = boundary
+            elif not end_elements:
+                # No end elements specified - use starts as both start and end
+                # Create section from previous start to this start (which acts as end)
+                start_elem = current_start["element"]
+                end_elem = boundary["element"]  # Use the actual boundary element as end
+
+                section = section_func(start_elem, end_elem, include_boundaries, orientation)
+                sections.append(section)
+
+                # This boundary becomes the new start
+                current_start = boundary
+
+        elif boundary["type"] == "end" and current_start:
+            # Create section from current start to this end
+            section = section_func(
+                current_start["element"], boundary["element"], include_boundaries, orientation
+            )
+            sections.append(section)
+            current_start = None
+
+    # Handle final section if we have an unclosed start
+    if current_start:
+        start_elem = current_start["element"]
+        # For the final section, we need to go to the end of the region
+        # Create a dummy end element at the region boundary
+        if orientation == "vertical":
+            # Create section to bottom of region
+            section = section_func(start_elem, None, include_boundaries, orientation)
+        else:
+            # Create section to right edge of region
+            section = section_func(start_elem, None, include_boundaries, orientation)
+        sections.append(section)
+
+    return sections

natural_pdf/utils/spatial.py

@@ -0,0 +1,169 @@
+"""Spatial utilities for consistent element-region relationships.
+
+This module centralizes the logic for determining whether elements belong to regions,
+ensuring consistent behavior across Region, Page, and Flow components.
+
+The default strategy is 'center' - an element belongs to a region if its center
+point falls within that region. This prevents double-counting of elements at
+boundaries and provides predictable behavior for operations like get_sections()
+with include_boundaries='none'.
+
+Example:
+    from natural_pdf.utils.spatial import is_element_in_region
+    
+    # Check if element is in region using center-based logic (default)
+    if is_element_in_region(element, region):
+        print("Element is in region")
+    
+    # Use different strategies
+    if is_element_in_region(element, region, strategy="intersects"):
+        print("Element overlaps with region")
+"""
+
+import logging
+from typing import TYPE_CHECKING, Literal, Optional
+
+if TYPE_CHECKING:
+    from natural_pdf.elements.base import Element
+    from natural_pdf.elements.region import Region
+
+logger = logging.getLogger(__name__)
+
+# Element inclusion strategies
+InclusionStrategy = Literal["center", "intersects", "contains"]
+
+
+def is_element_in_region(
+    element: "Element",
+    region: "Region", 
+    strategy: InclusionStrategy = "center",
+    check_page: bool = True
+) -> bool:
+    """
+    Unified function to check if an element is inside a region.
+    
+    This centralizes the logic used across Region, Page, and Flow to ensure
+    consistent behavior throughout the library.
+    
+    Args:
+        element: The element to check
+        region: The region to check against
+        strategy: The inclusion strategy to use:
+            - "center": Element belongs if its center point is inside (default)
+            - "intersects": Element belongs if any part overlaps
+            - "contains": Element belongs only if fully contained
+        check_page: Whether to verify element and region are on the same page
+        
+    Returns:
+        bool: True if element is in region according to the strategy
+    """
+    # Validate inputs
+    if not hasattr(element, "bbox") or not element.bbox:
+        logger.debug(f"Element lacks bbox attributes: {element}")
+        return False
+        
+    if not hasattr(region, "bbox") or not region.bbox:
+        logger.debug(f"Region lacks bbox attributes: {region}")
+        return False
+    
+    # Check page membership if requested
+    if check_page:
+        if not hasattr(element, "page") or not hasattr(region, "page"):
+            return False
+        if element.page != region.page:
+            return False
+    
+    # Apply the appropriate strategy
+    if strategy == "center":
+        # Use existing region method if available
+        if hasattr(region, "is_element_center_inside"):
+            return region.is_element_center_inside(element)
+        else:
+            # Fallback calculation
+            elem_center_x = (element.x0 + element.x1) / 2
+            elem_center_y = (element.top + element.bottom) / 2
+            
+            # Use region's is_point_inside if available
+            if hasattr(region, "is_point_inside"):
+                return region.is_point_inside(elem_center_x, elem_center_y)
+            else:
+                # Simple bounds check
+                return (region.x0 <= elem_center_x <= region.x1 and 
+                       region.top <= elem_center_y <= region.bottom)
+    
+    elif strategy == "intersects":
+        # Use existing region method if available
+        if hasattr(region, "intersects"):
+            return region.intersects(element)
+        else:
+            # Simple bbox overlap check
+            return not (element.x1 < region.x0 or 
+                       element.x0 > region.x1 or 
+                       element.bottom < region.top or 
+                       element.top > region.bottom)
+    
+    elif strategy == "contains":
+        # Use existing region method if available
+        if hasattr(region, "contains"):
+            return region.contains(element)
+        else:
+            # Simple full containment check
+            return (region.x0 <= element.x0 and 
+                   element.x1 <= region.x1 and 
+                   region.top <= element.top and 
+                   element.bottom <= region.bottom)
+    
+    else:
+        raise ValueError(f"Unknown inclusion strategy: {strategy}")
+
+
+def get_inclusion_strategy() -> InclusionStrategy:
+    """
+    Get the current global inclusion strategy.
+    
+    This could be made configurable via environment variable or settings.
+    For now, returns the default strategy.
+    
+    Returns:
+        The current inclusion strategy (default: "center")
+    """
+    # Could read from settings or environment
+    # return os.environ.get("NATURAL_PDF_INCLUSION_STRATEGY", "center")
+    return "center"
+
+
+def calculate_element_overlap_percentage(
+    element: "Element",
+    region: "Region"
+) -> float:
+    """
+    Calculate what percentage of an element overlaps with a region.
+    
+    Args:
+        element: The element to check
+        region: The region to check against
+        
+    Returns:
+        float: Percentage of element area that overlaps with region (0.0 to 1.0)
+    """
+    if not hasattr(element, "bbox") or not hasattr(region, "bbox"):
+        return 0.0
+    
+    # Calculate intersection bounds
+    intersect_x0 = max(element.x0, region.x0)
+    intersect_y0 = max(element.top, region.top) 
+    intersect_x1 = min(element.x1, region.x1)
+    intersect_y1 = min(element.bottom, region.bottom)
+    
+    # Check if there's an intersection
+    if intersect_x1 <= intersect_x0 or intersect_y1 <= intersect_y0:
+        return 0.0
+    
+    # Calculate areas
+    element_area = (element.x1 - element.x0) * (element.bottom - element.top)
+    if element_area == 0:
+        return 0.0
+        
+    intersect_area = (intersect_x1 - intersect_x0) * (intersect_y1 - intersect_y0)
+    
+    return intersect_area / element_area

{natural_pdf-0.2.16.dist-info → natural_pdf-0.2.17.dist-info}/METADATA

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

{natural_pdf-0.2.16.dist-info → natural_pdf-0.2.17.dist-info}/RECORD

@@ -1,8 +1,8 @@
-natural_pdf/__init__.py,sha256=N4pR0LbuPEnUYFZqbdVqc_FGKldgwPQc1wjJhYKTBBM,3417
+natural_pdf/__init__.py,sha256=N9ubwsFpmPj7WHA6Uewgn6IbmU2r0BeUGIdIhmTl6nw,4701
 natural_pdf/cli.py,sha256=0zO9ZoRiP8JmyGBaVavrMATnvbARWTl7WD2PEefu9BM,4061
 natural_pdf/text_mixin.py,sha256=eFCiHj6Okcw3aum4955BepcI2NPRalkf9UFFVTc_H30,4012
 natural_pdf/analyzers/__init__.py,sha256=3XGoNq3OgiVkZP7tOdeP5XVUl7fDgyztdA8DlOcMLXg,1138
-natural_pdf/analyzers/guides.py,sha256=B2_Etb0o-lOku-FQw-T1Fo1qxbcAXT4FB0hdp-5kXRs,188171
+natural_pdf/analyzers/guides.py,sha256=BqFgt-bRSOkEoFCvNsYyY8j__00X-8DJ_TLb2Hx9qsQ,202430
 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,27 +25,27 @@ 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=KPuKM7SstfErTkRnGq4vrgE0Tv8iazN13Jp7yAXGKso,55575
+natural_pdf/core/element_manager.py,sha256=619R97OtMd7uhaax7fZNJmhy9GxSs9HCNP4OzGgP828,55882
 natural_pdf/core/highlighting_service.py,sha256=wEV-koqHoHf7S3wZ3j8D2L-ucGp3Nd0YhhStz9yqeLc,70406
-natural_pdf/core/page.py,sha256=Pid5hqVjcyX-gcCzxCJ62k6AQhNbUMNM_5QmEcylIjM,155264
-natural_pdf/core/page_collection.py,sha256=IjdFq9q0D0P6ZKWInf0H25rLzxfMb7RsUXucogkhNkU,63169
+natural_pdf/core/page.py,sha256=-0OaIoXz0zjT_jnPjjI2jpb8vvNKh-1W56auA5UBhTA,158791
+natural_pdf/core/page_collection.py,sha256=bLZ3TqTQbmP3oYrbfEi7HUoPMbcGplEtUMZ3Z1y7fuw,66728
 natural_pdf/core/page_groupby.py,sha256=V2e_RNlHaasUzYm2h2vNJI7_aV_fl3_pg7kU3F2j0z8,8218
-natural_pdf/core/pdf.py,sha256=ovdeu9TRPnVYyMltD7QpcdcFYBLZFXh3LlfC5ifj6RY,104227
+natural_pdf/core/pdf.py,sha256=i8dYCimL_k5FV6BmPI1a2Dk7XZfwLP8TziXr2n3O_fI,105639
 natural_pdf/core/pdf_collection.py,sha256=s3ogu4CEHrHMTRqQMJUKJZ-9Ii8b_B9dWbVLTFj0s7g,34992
 natural_pdf/core/render_spec.py,sha256=y9QkMiIvWaKiEBlV0TjyldADIEUY3YfWLQXxStHu1S4,15480
 natural_pdf/describe/__init__.py,sha256=kIV7ORmWWB1SAur7nK2aAwR-wHqSedhKfUsaUl4hG0A,586
-natural_pdf/describe/base.py,sha256=LYbDjjQYOIZsYBbBQH3UP6XyWArJJvRc8LUugeVdJw0,18178
+natural_pdf/describe/base.py,sha256=M4TGXR8ppTvznTnA1ZDgMQMkDpgu1pwGMNaOcgHf2iY,20154
 natural_pdf/describe/elements.py,sha256=3Y541z5TQ2obrfZFiFi1YQMsCt3oYrhMHpD5j1tuppw,12639
 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=iJHEejlYu8RNvlKYK2UHAnAlz6tXkiEaGnG2xYtVnuU,59635
-natural_pdf/elements/element_collection.py,sha256=CVfnprzKTLeGSpvhGL2ZQVzZ8veSoFtCBlSSGDmX5lY,136594
+natural_pdf/elements/base.py,sha256=YYdoss63yv3IzQeuHbNypo7VLz2UJDFK5b6lqQe5tR8,76090
+natural_pdf/elements/element_collection.py,sha256=dlKoIaqmK_pC_cEcTX9LA2bNbZmc8iXcTTDfpHDlyUM,139812
 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=kmUmhwnihd-aTweAO-LsngRDo5Iqmx7lcSa8ZBlE_2E,4544
-natural_pdf/elements/region.py,sha256=DM8o0ptm86B2ouOqDgUK_av9cCN6G5iIlJ1VC3KfVWk,167379
-natural_pdf/elements/text.py,sha256=dOiss-cSBYnK9j7KqmqmvJcCidBcIhckLJCW8lVz2es,21210
+natural_pdf/elements/region.py,sha256=qJ86iToSjrCUjVrEbO0M0S1nTuZDW9tpI4jF9T5xJKs,168777
+natural_pdf/elements/text.py,sha256=Jo4gnrsJe1PStdoWF2Bt8RSeSmOcfA9DxvMJl7EoAmI,21344
 natural_pdf/export/mixin.py,sha256=L1q3MIEFWuvie4j4_EmW7GT3NerbZ1as0XMUoqTS7gM,5083
 natural_pdf/exporters/__init__.py,sha256=QffoARekR6WzXEd05oxOytly4qPdBizuIF-SUkeFpig,643
 natural_pdf/exporters/base.py,sha256=379sioW_hbkGb21sEVuJhbkkDO5MFsFtTUNO5TgG2YU,2101
@@ -62,9 +62,9 @@ natural_pdf/extraction/mixin.py,sha256=dBcp96R8zMQqaRHiB8vpyad8GR89gv5RPXlr8Mt0a
 natural_pdf/extraction/result.py,sha256=PDaCCN2LQBbHsZy0_lrQ0ROeMsnmH1WRoXWOjk9M2o4,1825
 natural_pdf/flows/__init__.py,sha256=cUN4A8hTDLZSRr4PO2W_lR4z6hWpbNG8Seox-IIcrLU,277
 natural_pdf/flows/collections.py,sha256=ErkHWdX6W_y1SjkcA_bGM0uUYRGPWWpRkHip6LHpej0,25740
-natural_pdf/flows/element.py,sha256=AWXGfAo0yhHTA5h0u4teXhRaV_z3McSPGOMFQaSdkJQ,24973
-natural_pdf/flows/flow.py,sha256=BuT3DBqNvLEqYle66-nZFO91i_1s98CAat28Dg-JjGU,86149
-natural_pdf/flows/region.py,sha256=r_cFtBlmPi7ADN3k8oYA1s_vyz8GeQLCnYcv58Zt5eM,52263
+natural_pdf/flows/element.py,sha256=rDfWICK2gXBMXiqX8D_l7866dkQwgAlJMkCFAFoz6xM,25044
+natural_pdf/flows/flow.py,sha256=MEls08CtkVox41du0wvkL3u11CAYzidQ6WxN1-vthUs,70591
+natural_pdf/flows/region.py,sha256=HMk4xfYJiKgER2KzRIcmXb1Vfp9amnyy0ay8YrLtV8w,55362
 natural_pdf/ocr/__init__.py,sha256=VY8hhvDPf7Gh2lB-d2QRmghLLyTy6ydxlgo1cS4dOSk,2482
 natural_pdf/ocr/engine.py,sha256=SwNlWydtHbrIghV5JD_j5B4-rnjCMYIWUIEARag-zHw,11839
 natural_pdf/ocr/engine_doctr.py,sha256=ptKrupMWoulZb-R93zr9btoe94JPWU7vlJuN7OBJEIM,17740
@@ -85,7 +85,7 @@ natural_pdf/search/search_options.py,sha256=sq_e8_jSROicD94b_xtDtLnjEr_Zsy4icjzP
 natural_pdf/search/search_service_protocol.py,sha256=u8pbuWP96fnQEe6mnreY9DrdiDAHP6ZCY7phvSbFlP8,6697
 natural_pdf/search/searchable_mixin.py,sha256=hqQ_AuID5eTGRCtKYdFLZ1zF35y73uk3x1M1VW9Il8U,23514
 natural_pdf/selectors/__init__.py,sha256=oZGeqSv53EqmIZOhcnawuaGGlRg1h79vArXuZCWKm4A,123
-natural_pdf/selectors/parser.py,sha256=WOoJlCxyz6F50uWJEBWSucANWMvihroezMBZMPCZxzE,40388
+natural_pdf/selectors/parser.py,sha256=HbPgmtXXA4lRSAVkCzw6vpCi3oh66e-53yUEPhYLGX8,46909
 natural_pdf/tables/__init__.py,sha256=sCvCGbGsL6BiqlNxAYfVv003bIDLI11FmjHhaWfcU6w,104
 natural_pdf/tables/result.py,sha256=-8ctA-jCJYSHtlfAoqTvhUwO5zSP2BQxxetAjqEsNyg,8665
 natural_pdf/templates/__init__.py,sha256=jYBxzfi73vew0f6yhIh1MlRxw4F_TVN2hKQR0YXOFe0,20
@@ -98,7 +98,10 @@ natural_pdf/utils/identifiers.py,sha256=P7n6owcubnF8oAMa_UfYtENmIaJQdH_AMC9Jbs2b
 natural_pdf/utils/layout.py,sha256=tJRRzwUVP0EeqqbGzr9yOuE5qFvhjZ9A44BuItmKGaU,753
 natural_pdf/utils/locks.py,sha256=7HJqV0VsNcOfISnbw8goCKWP5ck11uSJo6T_x9XIPKI,215
 natural_pdf/utils/packaging.py,sha256=TM0jafwS5yVbTGC-RMi4TyWunf9cUUo9h5J6rMzkT-o,22444
+natural_pdf/utils/pdfminer_patches.py,sha256=Ob81OMoNUGMUIy9nMw3deSQ_Z6cQmhbRlHUC3EHw2jk,4201
 natural_pdf/utils/reading_order.py,sha256=u7XyVZdKMPMK0CL1C7xFogKnZ92b0JKT068KFjQWe18,7437
+natural_pdf/utils/sections.py,sha256=HZX7829-fquKgIF7vUN2tL10-aXckEaM25g_2VcgWU4,12941
+natural_pdf/utils/spatial.py,sha256=JOH2LHnF5WBDcjNQsHQdj458zwUgKtSWW7Tj0motn70,5968
 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=TkoQtdODlh0n_99dsjLIWKE9dgK0m4jfrui_cQ3gTwU,221
@@ -108,7 +111,7 @@ natural_pdf/vision/similarity.py,sha256=HWmXDBNLSOlRWH-_1K3FVR7tSsRuMFqXZwrVhhg2
 natural_pdf/vision/template_matching.py,sha256=91XQt5tp-vmcMX_4b2Bz-YwIAlb-hc8E5ih_qAHQuCk,7145
 natural_pdf/widgets/__init__.py,sha256=QTVaUmsw__FCweFYZebwPssQxxUFUMd0wpm_cUbGZJY,181
 natural_pdf/widgets/viewer.py,sha256=KW3JogdR2TMg2ECUMYp8hwd060hfg8EsYBWxb5IEzBY,24942
-natural_pdf-0.2.16.dist-info/licenses/LICENSE,sha256=9zfwINwJlarbDmdh6iJV4QUG54QSJlSAUcnC1YiC_Ns,1074
+natural_pdf-0.2.17.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
@@ -145,8 +148,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.16.dist-info/METADATA,sha256=o2x-_hFHY64xJCCZM7CwEHo96vAU8XzFejobi1neE2g,6960
-natural_pdf-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-natural_pdf-0.2.16.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
-natural_pdf-0.2.16.dist-info/top_level.txt,sha256=ZDKhxE_tg508o9BpagsjCGcI8GY4cF_8bg0e0IaLsPI,41
-natural_pdf-0.2.16.dist-info/RECORD,,
+natural_pdf-0.2.17.dist-info/METADATA,sha256=8K5PCwh_OuI8vkWRLChHeT-LuEd0sRmigkRm55ZNeDo,6960
+natural_pdf-0.2.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+natural_pdf-0.2.17.dist-info/entry_points.txt,sha256=1R_KMv7g60UBBpRqGfw7bppsMNGdayR-iJlb9ohEk_8,81
+natural_pdf-0.2.17.dist-info/top_level.txt,sha256=ZDKhxE_tg508o9BpagsjCGcI8GY4cF_8bg0e0IaLsPI,41
+natural_pdf-0.2.17.dist-info/RECORD,,