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

temp/fix_page_exclusions.py

@@ -0,0 +1,42 @@
+"""Script to fix the remaining exclusion bugs in page.py"""
+
+import re
+
+# Read the file
+with open('/Users/soma/Development/natural-pdf/natural_pdf/core/page.py', 'r') as f:
+    content = f.read()
+
+# Fix 1: Line 1132 in find() method
+# Change: if apply_exclusions and self._exclusions and results_collection:
+# To: if apply_exclusions and results_collection:
+content = re.sub(
+    r'(\s+)if apply_exclusions and self\._exclusions and results_collection:',
+    r'\1if apply_exclusions and results_collection:',
+    content
+)
+
+# Fix 2: Line 1227 in find_all() method
+# Same change pattern
+content = re.sub(
+    r'(\s+)if apply_exclusions and self\._exclusions and results_collection:',
+    r'\1if apply_exclusions and results_collection:',
+    content
+)
+
+# Fix 3: Line 1599 in get_elements() method
+# Change: if apply_exclusions and self._exclusions:
+# To: if apply_exclusions:
+content = re.sub(
+    r'(\s+)if apply_exclusions and self\._exclusions:',
+    r'\1if apply_exclusions:',
+    content
+)
+
+# Write the fixed content back
+with open('/Users/soma/Development/natural-pdf/natural_pdf/core/page.py', 'w') as f:
+    f.write(content)
+
+print("Fixed exclusion checks in page.py")
+print("- find() method: removed self._exclusions check")
+print("- find_all() method: removed self._exclusions check")
+print("- get_elements() method: removed self._exclusions check")

temp/test_draw_guides.py

@@ -0,0 +1,25 @@
+"""Example usage of the interactive guide drawing feature"""
+
+# In a Jupyter notebook:
+from natural_pdf import NaturalPDF
+
+# Load a PDF
+pdf = NaturalPDF.from_file("your_pdf.pdf")
+page = pdf[0]
+
+# Create guides
+guides = page.guides()
+
+# Detect some initial guides (optional)
+guides.vertical.from_lines(n=5)
+guides.horizontal.from_lines(n=5)
+
+# Open interactive editor for vertical guides
+guides.vertical.draw()
+
+# Open interactive editor for horizontal guides
+guides.horizontal.draw(width=600)  # Smaller widget
+
+# After editing, the guides are automatically updated
+# You can now use them to extract tables:
+table = page.extract_table(guides)

temp/test_draw_guides_interactive.py

@@ -0,0 +1,30 @@
+"""Test the interactive guide drawing functionality"""
+
+from natural_pdf.core.pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load a sample PDF
+pdf = PDF("tests/sample_pdfs/simple_table.pdf")
+page = pdf.pages[0]
+
+# Create guides
+guides = Guides(page)
+
+# Add some initial guides for testing
+guides.vertical.from_content()
+guides.horizontal.from_lines(n=5)
+
+print("Initial vertical guides:", list(guides.vertical))
+print("Initial horizontal guides:", list(guides.horizontal))
+
+# This would open the interactive widget in Jupyter
+# guides.vertical.draw()
+
+# For non-Jupyter testing, we can check the method exists
+assert hasattr(guides.vertical, 'draw')
+assert callable(guides.vertical.draw)
+
+print("\nSuccess! The draw() method is available on GuidesList objects.")
+print("To use it interactively, run this in a Jupyter notebook:")
+print("  guides.vertical.draw()")
+print("  guides.horizontal.draw(width=600)")

temp/test_exclusion_with_debug.py

@@ -0,0 +1,30 @@
+"""Test exclusion 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")
+
+# First, verify the exclusion works on the page itself
+print("Page-level text extraction:")
+print("Without exclusions:", page.extract_text(apply_exclusions=False)[:100])
+print("With exclusions:", page.extract_text(apply_exclusions=True)[:100])
+
+# Now test on a specific region that should be excluded
+print("\n\nRegion in excluded area (0, 0, 200, 50):")
+excluded_region = page.region(0, 0, 200, 50)
+print("Without exclusions:", repr(excluded_region.extract_text(apply_exclusions=False)))
+print("With exclusions:", repr(excluded_region.extract_text(apply_exclusions=True)))
+
+# Test the actual problematic cell region
+print("\n\nProblematic cell region (32.06, 0.5, 73.18, 79.54):")
+cell_region = page.region(32.06, 0.5, 73.18288, 79.54)
+print("Without exclusions:", repr(cell_region.extract_text(apply_exclusions=False)))
+print("With exclusions:", repr(cell_region.extract_text(apply_exclusions=True)))
+
+# Check if the region inherits the page
+print(f"\nCell region's page: {cell_region.page}")
+print(f"Cell region's _page: {getattr(cell_region, '_page', 'Not found')}")
+print(f"Same as original page: {cell_region.page is page if hasattr(cell_region, 'page') else 'N/A'}")

temp/test_find_exclusions_fix.py

@@ -0,0 +1,53 @@
+"""Test that the find methods now work with PDF-level exclusions."""
+
+from natural_pdf import PDF
+
+# Load a test PDF
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add PDF-level exclusion for the header
+pdf.add_exclusion(lambda page: page.find(text="PREMISE").above())
+
+# Test 1: find() should now exclude the header text
+print("Test 1: find() with PDF-level exclusions")
+result = page.find("text:contains(FEBRUARY)", apply_exclusions=True)
+if result is None:
+    print("✅ SUCCESS: find() correctly excluded header text")
+else:
+    print(f"❌ FAILED: find() returned {result.text}")
+
+# Test 2: find_all() should exclude header elements
+print("\nTest 2: find_all() with PDF-level exclusions")
+all_text = page.find_all("text", apply_exclusions=False)
+filtered_text = page.find_all("text", apply_exclusions=True)
+print(f"Without exclusions: {len(all_text)} elements")
+print(f"With exclusions: {len(filtered_text)} elements")
+if len(filtered_text) < len(all_text):
+    print("✅ SUCCESS: find_all() excluded some elements")
+else:
+    print("❌ FAILED: find_all() didn't exclude any elements")
+
+# Test 3: get_elements() should exclude header elements
+print("\nTest 3: get_elements() with PDF-level exclusions")
+all_elements = page.get_elements(apply_exclusions=False)
+filtered_elements = page.get_elements(apply_exclusions=True)
+print(f"Without exclusions: {len(all_elements)} elements")
+print(f"With exclusions: {len(filtered_elements)} elements")
+if len(filtered_elements) < len(all_elements):
+    print("✅ SUCCESS: get_elements() excluded some elements")
+else:
+    print("❌ FAILED: get_elements() didn't exclude any elements")
+
+# Test that excluded text is not in the filtered results
+print("\nChecking excluded text...")
+excluded_texts = ["FEBRUARY", "ALPHABETIC LISTING", "M27"]
+for text in excluded_texts:
+    found_in_filtered = any(
+        text in str(el.text) if hasattr(el, 'text') else False 
+        for el in filtered_text
+    )
+    if not found_in_filtered:
+        print(f"✅ '{text}' correctly excluded")
+    else:
+        print(f"❌ '{text}' still present in filtered results")

temp/test_find_exclusions_fix_no_recursion.py

@@ -0,0 +1,97 @@
+"""Test that the find methods now work with PDF-level exclusions (without recursion)."""
+
+from natural_pdf import PDF
+
+# Load a test PDF
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Add PDF-level exclusion using a Region directly to avoid recursion
+# First, get the header region without exclusions
+header_element = page.find(text="PREMISE", apply_exclusions=False)
+if header_element:
+    header_region = header_element.above()
+    pdf.add_exclusion(header_region)
+else:
+    print("WARNING: Could not find PREMISE text for exclusion")
+
+# Test 1: find() should now exclude the header text
+print("Test 1: find() with PDF-level exclusions")
+result = page.find("text:contains(FEBRUARY)", apply_exclusions=True)
+if result is None:
+    print("✅ SUCCESS: find() correctly excluded header text")
+else:
+    print(f"❌ FAILED: find() returned {result.text}")
+
+# Test 2: find_all() should exclude header elements
+print("\nTest 2: find_all() with PDF-level exclusions")
+all_text = page.find_all("text", apply_exclusions=False)
+filtered_text = page.find_all("text", apply_exclusions=True)
+print(f"Without exclusions: {len(all_text)} elements")
+print(f"With exclusions: {len(filtered_text)} elements")
+if len(filtered_text) < len(all_text):
+    print("✅ SUCCESS: find_all() excluded some elements")
+else:
+    print("❌ FAILED: find_all() didn't exclude any elements")
+
+# Test 3: get_elements() should exclude header elements
+print("\nTest 3: get_elements() with PDF-level exclusions")
+all_elements = page.get_elements(apply_exclusions=False)
+filtered_elements = page.get_elements(apply_exclusions=True)
+print(f"Without exclusions: {len(all_elements)} elements")
+print(f"With exclusions: {len(filtered_elements)} elements")
+if len(filtered_elements) < len(all_elements):
+    print("✅ SUCCESS: get_elements() excluded some elements")
+else:
+    print("❌ FAILED: get_elements() didn't exclude any elements")
+
+# Test that excluded text is not in the filtered results
+print("\nChecking excluded text...")
+excluded_texts = ["FEBRUARY", "ALPHABETIC LISTING", "M27"]
+for text in excluded_texts:
+    found_in_filtered = any(
+        text in str(el.text) if hasattr(el, 'text') else False 
+        for el in filtered_text
+    )
+    if not found_in_filtered:
+        print(f"✅ '{text}' correctly excluded")
+    else:
+        print(f"❌ '{text}' still present in filtered results")
+
+# Also test that the original table extraction issue is fixed
+print("\n\nTesting original table extraction issue...")
+from natural_pdf.analyzers.guides import Guides
+
+# Add exclusion for footer too
+footer_element = page.find("text:regex(Page \\d+ of)", apply_exclusions=False)
+if footer_element:
+    pdf.add_exclusion(footer_element.expand())
+
+headers = (
+    page
+    .find(text="NUMBER", apply_exclusions=False)
+    .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()
+
+result = guides.extract_table(include_outer_boundaries=True, apply_exclusions=True, header=False)
+df = result.to_df()
+
+# Check if excluded content is in the table
+table_str = df.to_string()
+has_feb = "FEBRUARY" in table_str
+has_alphabetic = "ALPHABETIC LISTING" in table_str
+
+print(f"\nTable extraction with exclusions:")
+print(f"Contains 'FEBRUARY': {has_feb}")
+print(f"Contains 'ALPHABETIC LISTING': {has_alphabetic}")
+
+if not has_feb and not has_alphabetic:
+    print("✅ SUCCESS: Table extraction correctly excludes header/footer!")
+else:
+    print("❌ FAILED: Exclusions not working in table extraction")

temp/test_fix_real_pdf.py

@@ -0,0 +1,48 @@
+"""Test the fix with the actual PDF from the user's example."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Get headers using the user's exact code
+headers = (
+    page
+    .find("text:contains(NUMBER)")
+    .right(include_source=True)
+    .expand(top=3, bottom=3)
+    .find_all('text')
+)
+
+print("Headers found:")
+for i, h in enumerate(headers):
+    print(f"  {i}: '{h.text}' at x={h.x0:.2f}")
+
+# Create guides using ElementCollection
+guides = Guides(page)
+guides.vertical.from_content(headers, align='left', outer=False)
+
+print(f"\nResulting vertical guides: {sorted(guides.vertical)}")
+
+# Check specific headers that were problematic
+print("\nChecking headers 3-5:")
+for i, h in enumerate(headers[3:5]):
+    print(f"  Header {i+3}: '{h.text}' at x={h.x0:.5f}")
+
+# Test with just headers 3-5
+guides2 = Guides(page)
+guides2.vertical.from_content(headers[3:5], align='left', outer=False) 
+
+print(f"\nGuides from headers[3:5]: {guides2.vertical}")
+print(f"Expected: [328.32012, 539.63316]")
+
+# Verify the fix
+if 332.88095999999996 in guides2.vertical:
+    print("\n❌ FAILED: Extra guide at 332.88 is still present")
+else:
+    print("\n✅ SUCCESS: Extra guide at 332.88 is not present")
+
+# Test that outer guides work correctly too
+guides3 = Guides(page)
+guides3.vertical.from_content(headers[3:5], align='left', outer=True)
+print(f"\nWith outer=True: {guides3.vertical}")

temp/test_fix_working.py

@@ -0,0 +1,55 @@
+"""Test that the fix for region exclusions works"""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Check initial text
+print("Initial text:")
+print(page.extract_text()[:200])
+
+# Add exclusions
+pdf.add_exclusion(lambda page: page.find(text="PREMISE").above())
+pdf.add_exclusion(lambda page: page.find("text:regex(Page \d+ of)").expand())
+
+# Test region extraction with exclusions
+print("\n\nRegion in excluded area (0, 0, 200, 50):")
+excluded_region = page.region(0, 0, 200, 50)
+print("Without exclusions:", repr(excluded_region.extract_text(apply_exclusions=False)))
+print("With exclusions:", repr(excluded_region.extract_text(apply_exclusions=True)))
+
+# Now test the full table extraction
+print("\n\nFull table extraction:")
+headers = (
+    page
+    .find(text="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()
+
+result = guides.extract_table(include_outer_boundaries=True, apply_exclusions=True, header=False)
+df = result.to_df()
+
+print(f"Shape: {df.shape}")
+print("\nFirst row:")
+for col, val in df.iloc[0].items():
+    print(f"  {repr(col)}: {repr(val)}")
+
+# Check if excluded content is in the table
+table_str = df.to_string()
+has_feb = "FEBRUARY" in table_str or "FEBR" in table_str and "RUARY" in table_str
+has_alphabetic = "ALPHABETIC LISTING" in table_str
+
+print(f"\nContains 'FEBRUARY': {has_feb}")
+print(f"Contains 'ALPHABETIC LISTING': {has_alphabetic}")
+
+if has_feb or has_alphabetic:
+    print("\n❌ FAILED: Exclusions not working properly")
+else:
+    print("\n✅ SUCCESS: Exclusions working correctly!")

temp/test_fixed_pdf_exclusions.py

@@ -0,0 +1,67 @@
+"""Test PDF-level exclusions with proper Region returns."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load the PDF
+pdf = PDF("pdfs/m27.pdf")
+
+# Add PDF-level exclusions that properly return Regions
+print("Adding fixed PDF-level exclusions...")
+pdf.add_exclusion(
+    lambda page: page.find("text:contains(PREMISE)").above() 
+    if page.find("text:contains(PREMISE)") else None,
+    label="header_exclusion"
+)
+pdf.add_exclusion(
+    lambda page: page.find("text:regex(Page \d+ of)").expand(10) 
+    if page.find("text:regex(Page \d+ of)") else None,
+    label="footer_exclusion"
+)
+
+page = pdf.pages[0]
+
+# 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)
+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")
+    # Show what's in the first row/column that should be excluded
+    print("\nFirst column values (should not have header text):")
+    print(df.iloc[:5, 0])
+else:
+    print("\n✅ SUCCESS: 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)}")
+for i, exc in enumerate(exclusions):
+    print(f"  Exclusion {i}: {exc.bbox} (label: {exc.label})")

temp/test_guide_draw_notebook.py

@@ -0,0 +1,47 @@
+"""Test script to verify the draw() method works"""
+
+import sys
+sys.path.insert(0, '.')
+
+from natural_pdf.analyzers.guides import GuidesList, Guides
+
+# Create a mock context for testing
+class MockContext:
+    def __init__(self):
+        self.width = 600
+        self.height = 800
+        
+    def render(self, resolution=150):
+        # Create a simple test image
+        from PIL import Image
+        img = Image.new('RGB', (int(self.width * resolution/72), int(self.height * resolution/72)), 'white')
+        return img
+
+# Test that the draw method exists
+mock_context = MockContext()
+guides = Guides(mock_context)
+
+# Add some test guides
+guides.vertical.data = [100, 200, 300, 400, 500]
+guides.horizontal.data = [150, 350, 550, 750]
+
+print("Initial vertical guides:", list(guides.vertical))
+print("Initial horizontal guides:", list(guides.horizontal))
+
+# Check that draw method exists
+assert hasattr(guides.vertical, 'draw')
+assert callable(guides.vertical.draw)
+assert hasattr(guides.horizontal, 'draw')
+assert callable(guides.horizontal.draw)
+
+print("\nSuccess! The draw() method is available.")
+print("\nIn a Jupyter notebook, you would use:")
+print("  guides.vertical.draw()      # Interactive vertical guide editor")
+print("  guides.horizontal.draw()    # Interactive horizontal guide editor")
+print("\nFeatures:")
+print("  - Click to add new guides")
+print("  - Click existing guides to select them")
+print("  - Drag to move guides")
+print("  - Delete key to remove selected guide")
+print("  - Arrow keys to fine-tune position")
+print("  - Enter to apply, Escape to cancel")

temp/test_horizontal_top_bottom.py

@@ -0,0 +1,53 @@
+"""Test horizontal guides with top/bottom alignment on real PDF."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load the PDF
+pdf = PDF("pdfs/m27.pdf")
+page = pdf.pages[0]
+
+# Find some row headers to use as markers
+# First, let's find what text elements exist
+all_text = page.find_all('text')[:20]
+print("First 20 text elements:")
+for t in all_text:
+    print(f"  '{t.text}' at y={t.top:.2f}")
+
+# Look for rows containing numbers in the first column
+rows = page.find_all('text[x0<100]')[:5]  # Get elements in left column
+
+print("Found rows:")
+for i, row in enumerate(rows):
+    print(f"  {i}: '{row.text}' at y={row.top:.2f}-{row.bottom:.2f}")
+
+# Test with align='top' (should use top edge of each row)
+guides_top = Guides(page)
+guides_top.horizontal.from_content(rows, align='top', outer=False)
+
+print(f"\nHorizontal guides with align='top': {sorted(guides_top.horizontal)}")
+print("Expected: top edges of each row")
+
+# Test with align='bottom' (should use bottom edge of each row)
+guides_bottom = Guides(page)
+guides_bottom.horizontal.from_content(rows, align='bottom', outer=False)
+
+print(f"\nHorizontal guides with align='bottom': {sorted(guides_bottom.horizontal)}")
+print("Expected: bottom edges of each row")
+
+# Verify they're different
+if guides_top.horizontal != guides_bottom.horizontal:
+    print("\n✅ SUCCESS: top and bottom alignment produce different guides")
+else:
+    print("\n❌ FAILED: top and bottom alignment produced the same guides")
+
+# Test the class method too
+guides_class_top = Guides.from_content(page, axis='horizontal', markers=rows, align='top', outer=False)
+guides_class_bottom = Guides.from_content(page, axis='horizontal', markers=rows, align='bottom', outer=False)
+
+print(f"\nClass method with top: {sorted(guides_class_top.horizontal)}")
+print(f"Class method with bottom: {sorted(guides_class_bottom.horizontal)}")
+
+if guides_class_top.horizontal == guides_top.horizontal and guides_class_bottom.horizontal == guides_bottom.horizontal:
+    print("\n✅ SUCCESS: Class method produces same results as instance method")
+else:
+    print("\n❌ FAILED: Class method produces different results")

temp/test_inline_js.py

@@ -0,0 +1,22 @@
+"""Test inline JavaScript in HTML widget"""
+
+import ipywidgets as widgets
+from IPython.display import display
+
+# Create an HTML widget with inline JavaScript
+html_content = '''
+<div id="test-div">Click me!</div>
+<script type="text/javascript">
+document.getElementById('test-div').addEventListener('click', function() {
+    alert('Clicked!');
+    this.innerHTML = 'Clicked at ' + new Date().toLocaleTimeString();
+});
+console.log('JavaScript is running!');
+</script>
+'''
+
+# Display using widgets.HTML
+html_widget = widgets.HTML(value=html_content)
+display(html_widget)
+
+print("If you see 'Click me!' above and can click it, JavaScript is working.")

temp/test_marker_order.py

@@ -0,0 +1,45 @@
+"""Test marker ordering with a real PDF."""
+from natural_pdf import PDF
+
+# Load a test PDF
+pdf = PDF("pdfs/01-practice.pdf")
+page = pdf.pages[0]
+
+# Find some text elements to use as markers
+all_text = page.find_all("text")
+print("Sample text elements:")
+for i, elem in enumerate(all_text[:10]):
+    print(f"{i}: '{elem.text}' at x={elem.x0:.1f}")
+
+# Create guides with markers in specific order
+print("\n--- Testing vertical guides with markers ---")
+
+# Let's find specific text elements at different positions
+violations_elem = page.find('text:contains("Violations")')
+date_elem = page.find('text:contains("Date")')
+total_elem = page.find('text:contains("Total")')
+
+if violations_elem and date_elem and total_elem:
+    print(f"\nElement positions:")
+    print(f"'Violations' at x={violations_elem.x0:.1f}")
+    print(f"'Date' at x={date_elem.x0:.1f}")
+    print(f"'Total' at x={total_elem.x0:.1f}")
+    
+    # Create guides with markers in a specific order
+    guides = page.guides.from_content(
+        axis="vertical",
+        markers=["Violations", "Date", "Total"],
+        align="left",
+        outer=True
+    )
+    
+    print(f"\nResulting vertical guides: {sorted(guides.vertical)}")
+    print(f"Page bounds: {page.bbox}")
+    
+    # Show visually
+    page.guides.vertical.from_content(
+        markers=["Violations", "Date", "Total"],
+        align="left",
+        outer=True
+    )
+    page.show(guides=True)

temp/test_original_exclusions_now_work.py

@@ -0,0 +1,56 @@
+"""Test that the original exclusion lambdas (returning Elements) now work."""
+from natural_pdf import PDF
+from natural_pdf.analyzers.guides import Guides
+
+# Load the PDF
+pdf = PDF("pdfs/m27.pdf")
+
+# Add the ORIGINAL PDF-level exclusions that return Elements (not Regions)
+print("Adding original PDF-level exclusions (returning Elements)...")
+pdf.add_exclusion(lambda page: page.find("text:contains(PREMISE)").above())
+pdf.add_exclusion(lambda page: page.find("text:regex(Page \d+ of)"))
+
+page = pdf.pages[0]
+
+# 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
+table_result = guides.extract_table(include_outer_boundaries=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 with Element returns!")
+
+# Debug: Check exclusion regions with verbose output
+print("\n\nDebug: Checking exclusion regions...")
+exclusions = page._get_exclusion_regions(debug=True)
+print(f"\nTotal exclusion regions: {len(exclusions)}")
+for i, exc in enumerate(exclusions):
+    print(f"  Exclusion {i}: {exc.bbox} (label: {getattr(exc, 'label', 'None')})")