natural-pdf 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

temp/test_pdf_exclusions_with_guides.py

@@ -0,0 +1,84 @@
+"""Test that PDF-level exclusions work with guides.extract_table()."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load the PDF
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add PDF-level exclusions
+print("Adding PDF-level exclusions...")
+pdf.add_exclusion(lambda page: page.find("text:contains(PREMISE)").above())
+pdf.add_exclusion(lambda page: page.find("text:regex(Page \d+ of)"))
+
+# Create guides and extract table
+print("\nCreating guides and extracting table...")
+headers = (
+    page
+    .find("text:contains(NUMBER)")
+    .right(include_source=True)
+    .expand(top=3, bottom=3)
+    .find_all('text')
+)
+
+guides = Guides(page)
+guides.vertical.from_content(headers, align='left')
+guides.horizontal.from_stripes()
+
+# Extract table with apply_exclusions=True (default)
+table_result = guides.extract_table(include_outer_boundaries=True, apply_exclusions=True)
+df = table_result.to_df()
+
+print(f"\nTable shape: {df.shape}")
+print("\nFirst few rows:")
+print(df.head())
+
+# Check if excluded content is present
+print("\nChecking for excluded content...")
+table_text = df.to_string()
+has_alphabetic = "ALPHABETIC LISTING" in table_text
+has_page_num = "Page 1 of" in table_text or "Page" in table_text and "of" in table_text
+
+print(f"Contains 'ALPHABETIC LISTING': {has_alphabetic}")
+print(f"Contains 'Page X of Y': {has_page_num}")
+
+if has_alphabetic or has_page_num:
+    print("\n❌ FAILED: Exclusions not properly applied")
+else:
+    print("\n✅ SUCCESS: Exclusions properly applied")
+
+# Now test with page-level exclusions for comparison
+print("\n\nTesting with page-level exclusions...")
+page2 = pdf.pages[0]
+header = page2.find("text:contains(PREMISE)").above()
+footer = page2.find("text:regex(Page \d+ of)")
+
+if header:
+    page2.add_exclusion(header)
+if footer:
+    page2.add_exclusion(footer)
+
+guides2 = Guides(page2)
+guides2.vertical.from_content(headers, align='left')
+guides2.horizontal.from_stripes()
+
+table_result2 = guides2.extract_table(include_outer_boundaries=True)
+df2 = table_result2.to_df()
+
+print(f"\nTable shape with page exclusions: {df2.shape}")
+table_text2 = df2.to_string()
+has_alphabetic2 = "ALPHABETIC LISTING" in table_text2
+has_page_num2 = "Page 1 of" in table_text2 or "Page" in table_text2 and "of" in table_text2
+
+print(f"Contains 'ALPHABETIC LISTING': {has_alphabetic2}")
+print(f"Contains 'Page X of Y': {has_page_num2}")
+
+if has_alphabetic2 or has_page_num2:
+    print("\n❌ FAILED: Page exclusions not properly applied")
+else:
+    print("\n✅ SUCCESS: Page exclusions properly applied")
+
+# Debug: Check exclusion regions
+print("\n\nDebug: Checking exclusion regions...")
+exclusions = page._get_exclusion_regions(debug=True)
+print(f"\nTotal exclusion regions: {len(exclusions)}")

temp/test_region_exclusions_detailed.py

@@ -0,0 +1,25 @@
+"""Test region exclusions with detailed debugging"""
+from natural_pdf import PDF
+
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add exclusion
+pdf.add_exclusion(lambda page: page.find(text="PREMISE").above(), label="header")
+
+# Get page exclusions
+print("Page exclusions:")
+print(f"page._exclusions: {page._exclusions}")
+print(f"pdf._exclusions: {pdf._exclusions}")
+
+# Create a region in the excluded area
+test_region = page.region(0, 0, 200, 50)
+print(f"\nTest region: {test_region.bbox}")
+print(f"Region's page: {test_region.page}")
+print(f"Region's _page: {test_region._page}")
+print(f"Region's _page._exclusions: {test_region._page._exclusions}")
+
+# Try extraction with debug
+print("\nExtracting with debug=True:")
+text = test_region.extract_text(apply_exclusions=True, debug=True)
+print(f"Result: '{text}'")

temp/test_stripes_real_pdf.py

@@ -0,0 +1,62 @@
+"""Test from_stripes with a real PDF that has striped rows."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load the PDF (assuming m27.pdf has the striped table)
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Test 1: Manual selection with specific color
+print("Test 1: Manual selection with color='#00ffff'")
+guides = Guides(page)
+guides.horizontal.from_stripes(color='#00ffff')
+
+print(f"Found {len(guides.horizontal)} horizontal guides")
+if guides.horizontal:
+    print(f"Guide range: {min(guides.horizontal):.2f} to {max(guides.horizontal):.2f}")
+    print(f"First 5 guides: {sorted(guides.horizontal)[:5]}")
+
+# Test 2: Auto-detect most common stripe color
+print("\nTest 2: Auto-detect stripes")
+guides2 = Guides(page)
+guides2.horizontal.from_stripes()
+
+print(f"Found {len(guides2.horizontal)} horizontal guides")
+if guides2.horizontal:
+    print(f"Guide range: {min(guides2.horizontal):.2f} to {max(guides2.horizontal):.2f}")
+
+# Test 3: Manual selection of stripes
+print("\nTest 3: Manual selection of stripe elements")
+cyan_stripes = page.find_all('rect[fill=#00ffff]')
+print(f"Found {len(cyan_stripes)} cyan rectangles")
+
+if cyan_stripes:
+    guides3 = Guides(page)
+    guides3.horizontal.from_stripes(cyan_stripes)
+    print(f"Created {len(guides3.horizontal)} guides from stripes")
+    
+    # Show how this captures both edges of each stripe
+    print("\nFirst stripe edges:")
+    first_stripe = cyan_stripes[0]
+    print(f"  Stripe at y={first_stripe.top:.2f} to {first_stripe.bottom:.2f}")
+    print(f"  Guides include: {first_stripe.top:.2f} in guides? {first_stripe.top in guides3.horizontal}")
+    print(f"  Guides include: {first_stripe.bottom:.2f} in guides? {first_stripe.bottom in guides3.horizontal}")
+
+# Test 4: Compare with traditional approach
+print("\nComparison with traditional from_content approach:")
+# Traditional way would only get one edge per stripe
+guides4 = Guides(page)
+guides4.horizontal.from_content(cyan_stripes, align='top', outer=False)
+print(f"from_content (top only): {len(guides4.horizontal)} guides")
+
+guides5 = Guides(page)
+guides5.horizontal.from_content(cyan_stripes, align='bottom', outer=False)
+print(f"from_content (bottom only): {len(guides5.horizontal)} guides")
+
+print(f"from_stripes (both edges): {len(guides3.horizontal)} guides")
+
+# Verify we get approximately 2x guides with from_stripes
+if len(cyan_stripes) > 0:
+    expected_guides = len(set([s.top for s in cyan_stripes] + [s.bottom for s in cyan_stripes]))
+    print(f"\nExpected unique edges: {expected_guides}")
+    print(f"Actual from_stripes: {len(guides3.horizontal)}")

temp/test_vertical_stripes.py

@@ -0,0 +1,55 @@
+"""Test from_stripes with vertical stripes (column backgrounds)."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Create a mock page with vertical stripes (simulating column backgrounds)
+class MockRect:
+    def __init__(self, fill, x0, x1, top, bottom):
+        self.fill = fill
+        self.x0 = x0
+        self.x1 = x1
+        self.top = top
+        self.bottom = bottom
+
+class MockPage:
+    def __init__(self):
+        self.bbox = (0, 0, 800, 600)
+        # Create vertical stripes for alternating columns
+        self.stripes = [
+            MockRect('#f0f0f0', 100, 200, 0, 600),  # Column 1 background
+            MockRect('#f0f0f0', 300, 400, 0, 600),  # Column 3 background
+            MockRect('#f0f0f0', 500, 600, 0, 600),  # Column 5 background
+        ]
+        
+    def find_all(self, selector):
+        if selector == 'rect[fill=#f0f0f0]':
+            return self.stripes
+        elif selector == 'rect[fill]':
+            # Include some other rects too
+            return self.stripes + [
+                MockRect('#ffffff', 0, 100, 0, 600),
+                MockRect('#ffffff', 200, 300, 0, 600),
+            ]
+        return []
+
+# Test vertical stripes
+page = MockPage()
+guides = Guides(page)
+
+print("Testing vertical stripes (column backgrounds)")
+guides.vertical.from_stripes(color='#f0f0f0')
+
+print(f"\nFound {len(guides.vertical)} vertical guides")
+print(f"Guides at: {sorted(guides.vertical)}")
+
+# Verify we got both edges of each stripe
+expected = [100, 200, 300, 400, 500, 600]
+print(f"\nExpected: {expected}")
+print(f"Match: {sorted(guides.vertical) == expected}")
+
+# Test auto-detection
+guides2 = Guides(page)
+guides2.vertical.from_stripes()  # Should auto-detect the gray stripes
+
+print(f"\nAuto-detect found {len(guides2.vertical)} guides")
+print(f"Same result: {sorted(guides2.vertical) == sorted(guides.vertical)}")

temp/test_widget_functionality.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python
+"""Test the guide widget functionality"""
+
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Test importing and basic functionality
+try:
+    from natural_pdf.analyzers.guides import InteractiveGuideWidget, GuidesList, _GUIDE_WIDGET_AVAILABLE
+    print("✓ Successfully imported InteractiveGuideWidget")
+    
+    if _GUIDE_WIDGET_AVAILABLE:
+        print("✓ ipywidgets is available")
+        
+        # Create a mock GuidesList for testing
+        class MockPage:
+            def __init__(self):
+                self.bbox = (0, 0, 595, 842)  # A4 page size in points
+                
+            def render(self, resolution=150):
+                # Mock render method
+                from PIL import Image
+                width = int(595 * resolution / 72)
+                height = int(842 * resolution / 72)
+                return Image.new('RGB', (width, height), color='white')
+                
+        class MockGuides:
+            def __init__(self):
+                self.context = MockPage()
+                
+        class MockGuidesList:
+            def __init__(self):
+                self.data = [100, 200, 300]
+                self._axis = 'vertical'
+                self._parent = MockGuides()
+        
+        # Test creating the widget
+        mock_guides = MockGuidesList()
+        try:
+            widget = InteractiveGuideWidget(mock_guides)
+            print("✓ Successfully created InteractiveGuideWidget instance")
+            print(f"  - Widget ID: {widget.widget_id}")
+            print(f"  - Widget base classes: {InteractiveGuideWidget.__bases__}")
+            
+            # Check if the widget has the expected methods
+            expected_methods = ['_generate_content', 'update_guides']
+            for method in expected_methods:
+                if hasattr(widget, method):
+                    print(f"  - Has method: {method}")
+                else:
+                    print(f"  - Missing method: {method}")
+                    
+        except Exception as e:
+            print(f"✗ Error creating widget: {e}")
+            
+    else:
+        print("⚠ ipywidgets not available - widget functionality disabled")
+        
+except ImportError as e:
+    print(f"✗ Import error: {e}")
+    
+except Exception as e:
+    print(f"✗ Unexpected error: {e}")
+    
+print("\nWidget implementation test complete!")

temp/test_widget_simple.py

@@ -0,0 +1,41 @@
+#!/usr/bin/env python
+"""Simple test for the guide widget"""
+
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+# Test importing the module
+try:
+    from natural_pdf.analyzers.guides import InteractiveGuideWidget, _GUIDE_WIDGET_AVAILABLE
+    print(f"✓ Module imported successfully")
+    print(f"✓ Widget available: {_GUIDE_WIDGET_AVAILABLE}")
+    
+    if _GUIDE_WIDGET_AVAILABLE:
+        print("✓ ipywidgets is installed and InteractiveGuideWidget is available")
+    else:
+        print("✗ ipywidgets is not installed")
+        
+except ImportError as e:
+    print(f"✗ Import error: {e}")
+    sys.exit(1)
+
+# Check if we can create the widget class
+if _GUIDE_WIDGET_AVAILABLE:
+    try:
+        # We can't actually instantiate it without a GuidesList, but we can check the class exists
+        print(f"✓ InteractiveGuideWidget class: {InteractiveGuideWidget}")
+        print(f"✓ Widget base classes: {InteractiveGuideWidget.__bases__}")
+        
+        # Check methods
+        methods = [m for m in dir(InteractiveGuideWidget) if not m.startswith('_')]
+        print(f"✓ Public methods: {methods}")
+        
+    except Exception as e:
+        print(f"✗ Error checking widget class: {e}")
+else:
+    print("⚠ Skipping widget checks as ipywidgets is not available")
+
+print("\nAll checks passed!")