natural-pdf 0.2.17__tar.gz → 0.2.18__tar.gz

{natural_pdf-0.2.17/natural_pdf.egg-info → natural_pdf-0.2.18}/PKG-INFO

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

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/natural_pdf/core/page.py

@@ -1,5 +1,6 @@
 import base64
 import concurrent.futures  # Added import
+import contextlib
 import hashlib
 import io
 import json
@@ -275,6 +276,9 @@ class Page(
         self._load_elements()
         self._to_image_cache: Dict[tuple, Optional["Image.Image"]] = {}
 
+        # Flag to prevent infinite recursion when computing exclusions
+        self._computing_exclusions = False
+
     def _get_render_specs(
         self,
         mode: Literal["show", "render"] = "show",
@@ -412,6 +416,35 @@ class Page(
         self._exclusions = []
         return self
 
+    @contextlib.contextmanager
+    def without_exclusions(self):
+        """
+        Context manager that temporarily disables exclusion processing.
+
+        This prevents infinite recursion when exclusion callables themselves
+        use find() operations. While in this context, all find operations
+        will skip exclusion filtering.
+
+        Example:
+            ```python
+            # This exclusion would normally cause infinite recursion:
+            page.add_exclusion(lambda p: p.find("text:contains('Header')").expand())
+
+            # But internally, it's safe because we use:
+            with page.without_exclusions():
+                region = exclusion_callable(page)
+            ```
+
+        Yields:
+            The page object with exclusions temporarily disabled.
+        """
+        old_value = self._computing_exclusions
+        self._computing_exclusions = True
+        try:
+            yield self
+        finally:
+            self._computing_exclusions = old_value
+
     def add_exclusion(
         self,
         exclusion_func_or_region: Union[
@@ -759,15 +792,10 @@ class Page(
                     if debug:
                         print(f"  - Evaluating callable '{exclusion_label}'...")
 
-                    # Temporarily clear exclusions (consider if really needed)
-                    temp_original_exclusions = self._exclusions
-                    self._exclusions = []
-
-                    # Call the function - Expects it to return a Region or None
-                    region_result = exclusion_item(self)
-
-                    # Restore exclusions
-                    self._exclusions = temp_original_exclusions
+                    # Use context manager to prevent infinite recursion
+                    with self.without_exclusions():
+                        # Call the function - Expects it to return a Region or None
+                        region_result = exclusion_item(self)
 
                     if isinstance(region_result, Region):
                         # Assign the label to the returned region
@@ -947,6 +975,11 @@ class Page(
         Returns:
             A new list containing only the elements not excluded.
         """
+        # Skip exclusion filtering if we're currently computing exclusions
+        # This prevents infinite recursion when exclusion callables use find operations
+        if self._computing_exclusions:
+            return elements
+
         # Check both page-level and PDF-level exclusions
         has_page_exclusions = bool(self._exclusions)
         has_pdf_exclusions = (

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/natural_pdf/utils/spatial.py

@@ -10,11 +10,11 @@ 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")
@@ -35,16 +35,16 @@ InclusionStrategy = Literal["center", "intersects", "contains"]
 
 def is_element_in_region(
     element: "Element",
-    region: "Region", 
+    region: "Region",
     strategy: InclusionStrategy = "center",
-    check_page: bool = True
+    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
@@ -53,7 +53,7 @@ def is_element_in_region(
             - "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
     """
@@ -61,18 +61,18 @@ def is_element_in_region(
     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
@@ -82,37 +82,43 @@ def is_element_in_region(
             # 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)
-    
+                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)
-    
+            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)
-    
+            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}")
 
@@ -120,10 +126,10 @@ def is_element_in_region(
 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")
     """
@@ -132,38 +138,35 @@ def get_inclusion_strategy() -> InclusionStrategy:
     return "center"
 
 
-def calculate_element_overlap_percentage(
-    element: "Element",
-    region: "Region"
-) -> float:
+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_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
+
+    return intersect_area / element_area

{natural_pdf-0.2.17 → natural_pdf-0.2.18/natural_pdf.egg-info}/PKG-INFO

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

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/natural_pdf.egg-info/SOURCES.txt

@@ -230,6 +230,7 @@ temp/test_vertical_stripes.py
 temp/test_widget_functionality.py
 temp/test_widget_simple.py
 tests/conftest.py
+tests/demo_multipage.py
 tests/test_aggregate_selectors.py
 tests/test_annotate.py
 tests/test_arabic_performance.py
@@ -256,6 +257,7 @@ tests/test_element_show_crop_highlights.py
 tests/test_empty_pseudo_class.py
 tests/test_exclude_multi_page.py
 tests/test_exclude_real_pdf.py
+tests/test_exclusion_recursion_fix.py
 tests/test_exclusions.py
 tests/test_expand.py
 tests/test_expand_enhanced.py

natural_pdf-0.2.18/tests/demo_multipage.py

@@ -0,0 +1,56 @@
+"""Demo script showing multipage directional navigation."""
+
+import natural_pdf as npdf
+from natural_pdf import PDF
+
+
+def main():
+    """Demonstrate multipage directional navigation."""
+    pdf = PDF("pdfs/sections.pdf")
+
+    print("=== Multipage Directional Navigation Demo ===\n")
+
+    # Find Section 1 on page 1
+    section1 = pdf.pages[0].find("text:contains(Section 1)")
+    print(f"Found Section 1 on page {section1.page.number}")
+
+    # Without multipage - stops at page boundary
+    print("\n1. Without multipage=True:")
+    result = section1.below(until="text:contains(Section 6)")
+    print(f"   Result type: {type(result).__name__}")
+    print(f"   Result on page: {result.page.number}")
+    print(f"   Text excerpt: {result.extract_text()[:50]}...")
+
+    # With multipage=True - crosses page boundary
+    print("\n2. With multipage=True:")
+    result = section1.below(until="text:contains(Section 6)", multipage=True)
+    print(f"   Result type: {type(result).__name__}")
+    if hasattr(result, "constituent_regions"):
+        print(f"   Spans {len(result.constituent_regions)} pages")
+    text = result.extract_text()
+    print(f"   Contains 'Section 6': {'Section 6' in text}")
+
+    # Using global option
+    print("\n3. Using global auto_multipage option:")
+    original = npdf.options.layout.auto_multipage
+    npdf.set_option("layout.auto_multipage", True)
+
+    result = section1.below(until="text:contains(Section 6)")  # No multipage param needed!
+    print(f"   Result type: {type(result).__name__}")
+    text = result.extract_text()
+    print(f"   Contains 'Section 6': {'Section 6' in text}")
+
+    # Restore original setting
+    npdf.options.layout.auto_multipage = original
+
+    # Example of above() with multipage
+    print("\n4. Using above() with multipage:")
+    section6 = pdf.pages[1].find("text:contains(Section 6)")
+    result = section6.above(multipage=True)
+    print(f"   Result type: {type(result).__name__}")
+    if hasattr(result, "constituent_regions"):
+        print(f"   Spans {len(result.constituent_regions)} pages")
+
+
+if __name__ == "__main__":
+    main()

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/tests/test_aggregate_selectors.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from natural_pdf import NaturalPDF
+from natural_pdf import PDF
 from natural_pdf.elements.element_collection import ElementCollection
 
 
@@ -13,7 +13,7 @@ class TestAggregateSelectors:
     def sample_pdf(self):
         """Create a sample PDF for testing."""
         # This assumes we have a test PDF with various text sizes and positions
-        pdf = NaturalPDF("tests/fixtures/sample.pdf")
+        pdf = PDF("tests/fixtures/sample.pdf")
         return pdf
 
     def test_min_max_coordinates(self, sample_pdf):

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/tests/test_element_exclusions.py

@@ -17,6 +17,15 @@ def test_callable_exclusion_returning_element():
     mock_page._exclusions = []
     mock_page._parent = None
 
+    # Add context manager support to mock
+    from contextlib import contextmanager
+
+    @contextmanager
+    def mock_without_exclusions():
+        yield mock_page
+
+    mock_page.without_exclusions = mock_without_exclusions
+
     # Create mock element with expand() method
     mock_element = Mock()
     mock_element.bbox = (100, 200, 300, 400)
@@ -114,6 +123,15 @@ def test_pdf_level_element_exclusions():
     mock_page._exclusions = []
     mock_page._parent = mock_pdf
 
+    # Add context manager support to mock
+    from contextlib import contextmanager
+
+    @contextmanager
+    def mock_without_exclusions():
+        yield mock_page
+
+    mock_page.without_exclusions = mock_without_exclusions
+
     # Call _get_exclusion_regions
     from natural_pdf.core.page import Page
 

natural_pdf-0.2.18/tests/test_exclusion_recursion_fix.py

@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Test the exclusion recursion fix."""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import natural_pdf as npdf
+
+
+def test_exclusion_with_find():
+    """Test that exclusions using find() don't cause infinite recursion."""
+    # Create a simple test PDF
+    pdf = npdf.PDF("pdfs/sections.pdf")
+    page = pdf.pages[0]
+
+    # This should NOT cause infinite recursion anymore
+    # Use safer lambdas that handle None returns
+    page.add_exclusion(
+        lambda p: (
+            p.find("text:contains('Section')").above()
+            if p.find("text:contains('Section')")
+            else None
+        )
+    )
+    page.add_exclusion(lambda p: p.find("text").expand() if p.find("text") else None)
+
+    # Try to extract text - this should work without recursion
+    text = page.extract_text()
+    print(f"Successfully extracted {len(text)} characters")
+
+    # Try finding elements - this should also work
+    elements = page.find_all("text")
+    print(f"Found {len(elements)} text elements after applying exclusions")
+
+    # Test with ElementCollection return
+    page.add_exclusion(lambda p: p.find_all("text:contains('Header')"))
+    text2 = page.extract_text()
+    print(f"Successfully extracted {len(text2)} characters with ElementCollection exclusion")
+
+    print("✅ All tests passed - no infinite recursion!")
+
+
+if __name__ == "__main__":
+    test_exclusion_with_find()

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/tests/test_expand_enhanced.py

@@ -76,7 +76,7 @@ def test_expand_with_selectors():
     # Test expanding right until "Repeat?" (excluding)
     expanded = statute.expand(right='text:contains("Repeat?")')
     assert expanded.x0 == statute.x0
-    assert expanded.x1 == repeat.x0  # Should stop at the left edge of "Repeat?"
+    assert expanded.x1 == repeat.x0 - 0.01  # Should stop just before "Repeat?" with default offset
     assert expanded.top == statute.top
     assert expanded.bottom == statute.bottom
 
@@ -99,7 +99,7 @@ def test_expand_with_selectors_not_found():
     # Test with selector that won't match anything
     expanded = element.expand(right='text:contains("NonExistentText")')
     assert expanded.x0 == element.x0
-    assert expanded.x1 == element.x1  # Should remain unchanged
+    assert expanded.x1 == page.width  # Should expand to page edge when selector not found
     assert expanded.top == element.top
     assert expanded.bottom == element.bottom
 
@@ -127,7 +127,7 @@ def test_expand_mixed_parameters():
     # The right edge should be at "Repeat?" if found
     repeat = page.find('text:contains("Repeat?")')
     if repeat and repeat.x0 > element.x1:
-        assert expanded.x1 == repeat.x0
+        assert expanded.x1 == repeat.x0 - 0.01  # With default offset
 
 
 def test_expand_with_factors():

{natural_pdf-0.2.17 → natural_pdf-0.2.18}/tests/test_pdf_exclusions_in_find_methods.py

@@ -59,10 +59,12 @@ def test_find_with_pdf_exclusions():
 
     # Create a real page instance but with our mocked attributes
     page = Page.__new__(Page)
-    page.index = 0
+    page._index = 0  # Set the internal _index attribute
     page._exclusions = []
     page._parent = mock_pdf
     page._page_obj = Mock()
+    page._computing_exclusions = False  # Add the new flag
+    page._computing_exclusions = False  # Add the new flag
 
     # Mock the internal methods we need
     page._get_exclusion_regions = Mock(return_value=[mock_region])
@@ -113,10 +115,11 @@ def test_find_all_with_pdf_exclusions():
 
     # Create a real page instance
     page = Page.__new__(Page)
-    page.index = 0
+    page._index = 0  # Set the internal _index attribute
     page._exclusions = []
     page._parent = mock_pdf
     page._page_obj = Mock()
+    page._computing_exclusions = False  # Add the new flag
 
     # Mock the methods
     mock_collection = Mock(spec=ElementCollection)
@@ -142,17 +145,22 @@ def test_get_elements_with_pdf_exclusions():
 
     # Create a real page instance
     page = Page.__new__(Page)
-    page.index = 0
+    page._index = 0  # Set the internal _index attribute
     page._exclusions = []  # Empty page exclusions
     page._parent = mock_pdf
     page._page_obj = Mock()
+    page._computing_exclusions = False  # Add the new flag
 
     # Mock elements
     all_elements = [Mock(), Mock(), Mock()]
     filtered_elements = [all_elements[0], all_elements[2]]  # Exclude middle one
 
-    # Mock the methods
-    page._get_all_elements = Mock(return_value=all_elements)
+    # Mock the element manager
+    mock_element_mgr = Mock()
+    mock_element_mgr.get_all_elements = Mock(return_value=all_elements)
+    page._element_mgr = mock_element_mgr
+
+    # Mock the filter method
     page._filter_elements_by_exclusions = Mock(return_value=filtered_elements)
 
     # Test get_elements() with apply_exclusions=True