natural-pdf 25.3.16__py3-none-any.whl

examples/document_layout_analysis.py

@@ -0,0 +1,123 @@
+"""
+Document layout analysis example using YOLO model.
+
+This example demonstrates how to use the document layout analysis
+functionality to detect and extract content from different regions
+of a PDF document.
+"""
+import os
+import sys
+import argparse
+
+# Add the parent directory to the Python path
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+from natural_pdf import PDF
+
+# Get the current directory of this script
+script_dir = os.path.dirname(os.path.realpath(__file__))
+# Get the parent directory (project root)
+root_dir = os.path.dirname(script_dir)
+# Default PDF path
+default_pdf = os.path.join(root_dir, "pdfs", "2019 Statistics.pdf")
+
+# Set up argument parser
+parser = argparse.ArgumentParser(description="Document layout analysis example")
+parser.add_argument("pdf_path", nargs="?", default=default_pdf, help="Path to a PDF file")
+parser.add_argument("--page", type=int, default=0, help="Page number to analyze (0-based)")
+parser.add_argument("--conf", type=float, default=0.2, help="Confidence threshold for detections")
+parser.add_argument("--model-path", type=str, default=None, help="Path to custom YOLO model")
+parser.add_argument("--device", type=str, default="cpu", help="Device to run inference on ('cpu' or 'cuda:0')")
+parser.add_argument("--output", type=str, default=None, help="Output file path for highlighted image")
+args = parser.parse_args()
+
+print(f"Analyzing PDF: {args.pdf_path}")
+print(f"Page: {args.page}")
+print(f"Confidence threshold: {args.conf}")
+
+# Load the PDF
+pdf = PDF(args.pdf_path)
+page = pdf.pages[args.page]
+
+print(f"Running document layout analysis...")
+
+# Run document layout analysis
+# The analyze_layout method now returns self for method chaining
+page.analyze_layout(
+    confidence=args.conf,
+    model_path=args.model_path,
+    device=args.device
+)
+
+print(f"Found {len(page.detected_layout_regions)} regions with confidence >= {args.conf}")
+
+# Group regions by type
+regions_by_type = {}
+for region in page.detected_layout_regions:
+    region_type = region.region_type
+    if region_type not in regions_by_type:
+        regions_by_type[region_type] = []
+    regions_by_type[region_type].append(region)
+    
+# Print a summary of detected regions by type
+for region_type, type_regions in regions_by_type.items():
+    print(f"  - {region_type}: {len(type_regions)} regions")
+    
+# You can highlight layout regions in two ways:
+# 1. Using the dedicated highlight_layout method
+# page.highlight_layout(regions, confidence=args.conf)
+
+# 2. Using highlight_all with include_layout_regions=True
+page.highlight_all(include_layout_regions=True, layout_confidence=args.conf)
+
+# Demonstrate using selectors to find regions by type
+print("\nSelecting regions by type:")
+for region_type in regions_by_type.keys():
+    # Convert spaces to hyphens for selector syntax
+    selector_type = region_type.lower().replace(' ', '-')
+    selector = f"region[type={selector_type}]"
+    
+    found_regions = page.find_all(selector)
+    print(f"  - {selector}: {len(found_regions)} regions")
+    
+    # Extract text from the first region if available
+    if found_regions:
+        text = found_regions[0].extract_text()
+        preview = text[:50] + "..." if len(text) > 50 else text
+        print(f"    First region text: {preview}")
+
+# Finding high-confidence titles
+high_conf_titles = page.find_all('region[type=title][confidence>=0.8]')
+if high_conf_titles:
+    print(f"\nFound {len(high_conf_titles)} high-confidence titles:")
+    for i, title in enumerate(high_conf_titles):
+        text = title.extract_text().strip()
+        print(f"  {i+1}. {text} (conf: {title.confidence:.2f})")
+
+# Save the highlighted image
+output_path = args.output or os.path.join(root_dir, "output", "layout_detection.png")
+os.makedirs(os.path.dirname(output_path), exist_ok=True)
+print(f"\nSaving highlighted layout to {output_path}")
+page.to_image(path=output_path, show_labels=True)
+print(f"Done!")
+
+# Show an example of using a detected region for further analysis
+if "table" in regions_by_type and regions_by_type["table"]:
+    print("\nExample: Working with a detected table region")
+    table_region = regions_by_type["table"][0]
+    
+    # Highlight the table region with a specific color
+    table_region.highlight(label="Selected Table", color=(0, 1, 0, 0.3))
+    
+    # Find text elements within the table region
+    table_text = table_region.find_all('text')
+    print(f"  Found {len(table_text)} text elements in the table")
+    
+    # Extract the table text
+    table_content = table_region.extract_text()
+    preview = table_content[:100] + "..." if len(table_content) > 100 else table_content
+    print(f"  Table content: {preview}")
+    
+    # Save the highlighted table
+    table_output = os.path.join(os.path.dirname(output_path), "detected_table.png")
+    page.to_image(path=table_output, show_labels=True)
+    print(f"  Table highlighted image saved to {table_output}")

examples/document_qa_example.py

@@ -0,0 +1,185 @@
+"""
+Example demonstrating the Document QA capabilities of Natural PDF.
+
+This example shows how to:
+1. Ask questions to a PDF document
+2. Ask questions to specific pages
+3. Ask questions to specific regions
+4. Control confidence thresholds
+5. Highlight answer elements
+6. Handle QA results
+
+Requirements:
+- transformers
+- torch
+"""
+
+import os
+import sys
+import argparse
+from PIL import Image, ImageDraw, ImageFont
+import logging
+from typing import Dict, Any
+
+# Add parent directory to path to run without installing
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from natural_pdf import PDF, configure_logging
+
+def format_qa_result(result: Dict[str, Any]) -> str:
+    """Format a QA result as a string."""
+    if not result.get("found", False):
+        return f"No answer found. {result.get('message', '')}"
+    
+    answer = result.get("answer", "")
+    confidence = result.get("confidence", 0.0)
+    page_num = result.get("page_num", 0)
+    
+    return f"Answer: {answer} (confidence: {confidence:.2f}, page: {page_num})"
+
+def main():
+    parser = argparse.ArgumentParser(description="Document QA Example")
+    parser.add_argument("pdf_path", nargs="?", default="../pdfs/0500000US42001.pdf", 
+                      help="Path to PDF document")
+    parser.add_argument("--questions", nargs="+", 
+                      default=["How many votes for Harris and Walz?", 
+                              "How many votes for Trump and Vance?", 
+                              "What precinct is this for?", 
+                              "What state is this for?"], 
+                      help="Questions to ask")
+    parser.add_argument("--highlight", action="store_true", 
+                      help="Highlight answer elements")
+    parser.add_argument("--min-confidence", type=float, default=0.2,
+                      help="Minimum confidence threshold (0.0-1.0)")
+    parser.add_argument("--verbose", action="store_true",
+                      help="Enable verbose output")
+    parser.add_argument("--model", default="impira/layoutlm-document-qa",
+                      help="Model to use (default: impira/layoutlm-document-qa)")
+    parser.add_argument("--region", action="store_true",
+                      help="Ask questions to specific regions instead of whole pages")
+    
+    args = parser.parse_args()
+    
+    # Configure logging
+    log_level = logging.DEBUG if args.verbose else logging.INFO
+    configure_logging(level=log_level)
+    
+    # Open the PDF
+    pdf = PDF(args.pdf_path)
+    page = pdf.pages[0]  # Use the first page for this example
+    
+    print(f"Document: {args.pdf_path}")
+    print(f"Page count: {len(pdf.pages)}")
+    print(f"Model: {args.model}")
+    print(f"Minimum confidence: {args.min_confidence}")
+    print()
+    
+    # Create output directory if not exists
+    os.makedirs("output", exist_ok=True)
+    
+    # If using regions, detect document layout
+    if args.region:
+        print("Detecting document layout...")
+        page.analyze_layout(confidence=0.3)
+        regions = page.find_all('region')
+        print(f"Found {len(regions)} regions")
+        
+        # Save an image with detected regions
+        page.highlight_layout()
+        page.save_image("output/document_qa_regions.png")
+        print("Saved layout visualization to output/document_qa_regions.png")
+        print()
+    
+    # Process each question
+    for i, question in enumerate(args.questions):
+        print(f"Question {i+1}: {question}")
+        
+        if args.region:
+            # Ask each region (sort by confidence)
+            all_results = []
+            for region in regions:
+                if region.region_type in ['title', 'plain-text', 'table', 'list']:
+                    result = region.ask(
+                        question=question,
+                        min_confidence=args.min_confidence,
+                        model=args.model
+                    )
+                    if result.get("found", False):
+                        all_results.append(result)
+            
+            # Sort by confidence
+            all_results.sort(key=lambda x: x.get("confidence", 0), reverse=True)
+            
+            if all_results:
+                result = all_results[0]  # Use the highest confidence result
+                print(format_qa_result(result))
+                
+                # Highlight the answer if requested
+                if args.highlight and result.get("source_elements"):
+                    highlight_image = page.duplicate()
+                    region_type = result["region"].region_type if "region" in result else "unknown"
+                    for element in result["source_elements"]:
+                        element.highlight(color=(1, 0.5, 0, 0.5))  # Orange highlight
+                    
+                    # Add question and answer as text annotation
+                    highlight_image.annotate_text(
+                        x=50, y=20, 
+                        text=f"Q: {question}\nA: {result['answer']} (confidence: {result['confidence']:.2f}, region: {region_type})",
+                        font_size=14,
+                        color=(0, 0, 0)
+                    )
+                    
+                    # Save the highlighted image
+                    output_path = f"output/document_qa_answer_{i+1}.png"
+                    highlight_image.save_image(output_path)
+                    print(f"Saved answer visualization to {output_path}")
+            else:
+                print("No answer found in any region")
+        else:
+            # Ask the whole page
+            result = page.ask(
+                question=question,
+                min_confidence=args.min_confidence,
+                model=args.model
+            )
+            
+            print(format_qa_result(result))
+            
+            # Highlight the answer if requested
+            if args.highlight and result.get("found", False) and result.get("source_elements"):
+                highlight_image = page.duplicate()
+                for element in result["source_elements"]:
+                    element.highlight(color=(1, 0.5, 0, 0.5))  # Orange highlight
+                
+                # Add question and answer as text annotation
+                highlight_image.annotate_text(
+                    x=50, y=20, 
+                    text=f"Q: {question}\nA: {result['answer']} (confidence: {result['confidence']:.2f})",
+                    font_size=14,
+                    color=(0, 0, 0)
+                )
+                
+                # Save the highlighted image
+                output_path = f"output/document_qa_answer_{i+1}.png"
+                highlight_image.save_image(output_path)
+                print(f"Saved answer visualization to {output_path}")
+        
+        print()
+    
+    # Try a different PDF approach - ask the whole document
+    print("Asking questions to the whole document:")
+    
+    for i, question in enumerate(args.questions):
+        print(f"Question {i+1}: {question}")
+        
+        result = pdf.ask(
+            question=question,
+            min_confidence=args.min_confidence,
+            model=args.model
+        )
+        
+        print(format_qa_result(result))
+        print()
+
+if __name__ == "__main__":
+    main()

examples/exclusion_count_debug.py

@@ -0,0 +1,128 @@
+"""
+Debug script to compare element counts with different exclusion methods.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from natural_pdf import PDF
+
+
+def debug_element_counts():
+    # Get PDF path - use a default if one isn't specified
+    # Look for any PDF in the examples directory or pdfs directory
+    example_dir = Path(__file__).parent
+    pdf_files = list(example_dir.glob("*.pdf"))
+    
+    if not pdf_files:
+        pdfs_dir = example_dir.parent / "pdfs"
+        if pdfs_dir.exists():
+            pdf_files = list(pdfs_dir.glob("*.pdf"))
+    
+    if pdf_files:
+        pdf_path = str(pdf_files[0])
+    else:
+        print("No PDF file found.")
+        sys.exit(1)
+    
+    print(f"Using PDF: {pdf_path}")
+
+    # Case 1: Direct page-level exclusion
+    print("\n=== Case 1: Direct page-level exclusion ===")
+    pdf1 = PDF(pdf_path)
+    page1 = pdf1.pages[0]
+    
+    # First count without exclusions
+    all_text_no_exclusions = page1.find_all('text')
+    print(f"Before exclusion: {len(all_text_no_exclusions)} text elements")
+    
+    # Count the elements in the region to be excluded
+    line1 = page1.find('line')
+    region_above = line1.above()
+    elements_in_region = page1.find_all('text')
+    excluded_count = 0
+    for element in elements_in_region:
+        if region_above._is_element_in_region(element):
+            excluded_count += 1
+    print(f"Region above line contains {excluded_count} elements")
+    
+    # Now add the exclusion and count again
+    page1.add_exclusion(region_above)
+    all_text_with_exclusion = page1.find_all('text')
+    print(f"After direct exclusion: {len(all_text_with_exclusion)} text elements")
+    print(f"Elements excluded: {len(all_text_no_exclusions) - len(all_text_with_exclusion)}")
+
+    # Debug the exclusion regions
+    exclusion_regions = page1._get_exclusion_regions(include_callable=True)
+    print(f"Found {len(exclusion_regions)} exclusion regions")
+    for i, region in enumerate(exclusion_regions):
+        print(f"  Region {i+1}: top={region.top}, bottom={region.bottom}, x0={region.x0}, x1={region.x1}")
+    
+    # Case 2: PDF-level exclusion with lambda
+    print("\n=== Case 2: PDF-level exclusion with lambda ===")
+    pdf2 = PDF(pdf_path)
+    
+    # Add lambda exclusion at PDF level
+    pdf2.add_exclusion(lambda page: page.find('line').above())
+    page2 = pdf2.pages[0]
+    
+    # Count after exclusion
+    all_text_with_lambda_exclusion = page2.find_all('text')
+    print(f"After PDF-level exclusion: {len(all_text_with_lambda_exclusion)} text elements")
+    
+    # Debug the exclusion regions
+    print("\nExclusion regions from PDF-level lambda:")
+    exclusion_regions = page2._get_exclusion_regions(include_callable=True, debug=True)
+    print(f"Found {len(exclusion_regions)} exclusion regions")
+    for i, region in enumerate(exclusion_regions):
+        print(f"  Region {i+1}: top={region.top}, bottom={region.bottom}, x0={region.x0}, x1={region.x1}")
+    
+    # Compare results
+    print("\n=== Comparison ===")
+    print(f"Direct page exclusion count: {len(all_text_with_exclusion)}")
+    print(f"PDF-level lambda exclusion count: {len(all_text_with_lambda_exclusion)}")
+    
+    # Examine if the region generated by the lambda is identical to the direct region
+    if len(exclusion_regions) > 0:
+        direct_region = region_above
+        lambda_region = exclusion_regions[0]
+        
+        print("\nRegion comparison:")
+        print(f"Direct region: top={direct_region.top}, bottom={direct_region.bottom}, x0={direct_region.x0}, x1={direct_region.x1}")
+        print(f"Lambda region: top={lambda_region.top}, bottom={lambda_region.bottom}, x0={lambda_region.x0}, x1={lambda_region.x1}")
+        
+        # Check if regions are identical
+        regions_identical = (
+            direct_region.top == lambda_region.top and
+            direct_region.bottom == lambda_region.bottom and
+            direct_region.x0 == lambda_region.x0 and
+            direct_region.x1 == lambda_region.x1
+        )
+        print(f"Regions are identical: {regions_identical}")
+    
+    # Case 3: Modified lambda approach - create a lambda that exactly reproduces the region
+    print("\n=== Case 3: Explicit region lambda ===")
+    pdf3 = PDF(pdf_path)
+    
+    # Get the exact coordinates from the first run
+    line3 = pdf1.pages[0].find('line')
+    region3 = line3.above()
+    
+    # Create a lambda that returns a fixed region with those coordinates
+    def fixed_region_lambda(page):
+        return page.create_region(region3.x0, region3.top, region3.x1, region3.bottom)
+    
+    pdf3.add_exclusion(fixed_region_lambda)
+    page3 = pdf3.pages[0]
+    
+    # Count with this explicit region lambda
+    all_text_with_explicit_lambda = page3.find_all('text')
+    print(f"With explicit region lambda: {len(all_text_with_explicit_lambda)} text elements")
+
+
+if __name__ == "__main__":
+    debug_element_counts()

examples/exclusion_debug.py

@@ -0,0 +1,107 @@
+"""
+Example to debug exclusion issues with highlighting.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from natural_pdf import PDF
+
+
+def debug_exclusions():
+    """Debug exclusion problem."""
+    # Get PDF path - use a default if one isn't specified
+    # Look for any PDF in the examples directory or pdfs directory
+    example_dir = Path(__file__).parent
+    pdf_files = list(example_dir.glob("*.pdf"))
+    
+    if not pdf_files:
+        pdfs_dir = example_dir.parent / "pdfs"
+        if pdfs_dir.exists():
+            pdf_files = list(pdfs_dir.glob("*.pdf"))
+    
+    if pdf_files:
+        pdf_path = str(pdf_files[0])
+    else:
+        print("No PDF file found. Please provide a path to a PDF file.")
+        sys.exit(1)
+    
+    print(f"Using PDF: {pdf_path}")
+
+    # Case 1: Direct page exclusion - expected to work
+    print("\n=== Case 1: Direct page exclusion ===")
+    pdf1 = PDF(pdf_path)
+    page1 = pdf1.pages[0]
+    
+    # Create a debug output directory
+    output_dir = Path(__file__).parent / "debug_output"
+    output_dir.mkdir(exist_ok=True)
+    
+    # First, save without exclusions for comparison
+    page1.highlight_all()
+    page1.save(str(output_dir / "case1_no_exclusion.png"), labels=True)
+    page1.clear_highlights()
+    
+    # Log exclusions we're adding
+    line1 = page1.find('line')
+    print(f"Adding exclusion for region above line at {line1.top}")
+    
+    # Add exclusion directly to page
+    page1.add_exclusion(line1.above())
+    
+    # Show all exclusion regions
+    exclusion_regions = page1._get_exclusion_regions(include_callable=True)
+    print(f"Found {len(exclusion_regions)} exclusion regions")
+    for i, region in enumerate(exclusion_regions):
+        print(f"  Region {i+1}: top={region.top}, bottom={region.bottom}")
+    
+    # Apply highlight with exclusions
+    page1.highlight_all(apply_exclusions=True)
+    page1.save(str(output_dir / "case1_with_exclusion.png"), labels=True)
+    
+    # Case 2: PDF-level exclusion - not working correctly
+    print("\n=== Case 2: PDF-level exclusion ===")
+    pdf2 = PDF(pdf_path)
+    
+    # This should work exactly the same as Case 1
+    pdf2.add_exclusion(lambda page: page.find('line').above())
+    page2 = pdf2.pages[0]
+    
+    # Show all exclusion regions for comparison
+    exclusion_regions = page2._get_exclusion_regions(include_callable=True, debug=True)
+    print(f"Found {len(exclusion_regions)} exclusion regions")
+    for i, region in enumerate(exclusion_regions):
+        print(f"  Region {i+1}: top={region.top}, bottom={region.bottom}")
+    
+    # Save highlighting result
+    page2.highlight_all(apply_exclusions=True)
+    page2.save(str(output_dir / "case2_with_exclusion.png"), labels=True)
+    
+    # Case 3: Using find_all with exclusions - for comparison
+    print("\n=== Case 3: Using find_all with exclusions ===")
+    pdf3 = PDF(pdf_path)
+    pdf3.add_exclusion(lambda page: page.find('line').above())
+    page3 = pdf3.pages[0]
+    
+    # Check what find_all returns with exclusions
+    all_text = page3.find_all('text', apply_exclusions=True)
+    print(f"find_all('text') returns {len(all_text)} elements with exclusions")
+    
+    # Highlight just those elements
+    all_text.highlight(label="Text with exclusions")
+    page3.save(str(output_dir / "case3_find_all_with_exclusion.png"), labels=True)
+    
+    # Compare to highlight_all
+    page3.clear_highlights()
+    page3.highlight_all(apply_exclusions=True)
+    page3.save(str(output_dir / "case3_highlight_all.png"), labels=True)
+    
+    print(f"\nResults saved to {output_dir}")
+
+
+if __name__ == "__main__":
+    debug_exclusions()

examples/exclusion_example.py

@@ -0,0 +1,150 @@
+"""
+Example demonstrating how to use exclusion zones in Natural PDF.
+"""
+
+import os
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from natural_pdf import PDF
+
+
+def example_page_level_exclusion(pdf_path):
+    """
+    Example demonstrating page-level exclusion zones.
+    """
+    with PDF(pdf_path) as pdf:
+        page = pdf.pages[0]
+        
+        # Print the full text for comparison
+        print("\n--- Original Text ---")
+        print(page.extract_text())
+        
+        # Add an exclusion for anything above a heading
+        print("\n--- After Excluding Header ---")
+        header = page.find('text:contains("Summary")')
+        if header:
+            # Add the exclusion and extract text with it applied
+            page.add_exclusion(header.above())
+            print(page.extract_text())
+        else:
+            print("Header not found. Try with a different selector.")
+        
+        # Add another exclusion for content below the last line
+        print("\n--- After Excluding Header and Footer ---")
+        lines = page.find_all('line')
+        if lines and len(lines) > 0:
+            last_line = lines.last if hasattr(lines, 'last') else lines[-1]
+            # Add the second exclusion
+            page.add_exclusion(last_line.below())
+            print(page.extract_text())
+        else:
+            print("Line not found. Try with a different selector.")
+            
+        # Show that we can disable exclusions if needed
+        print("\n--- With Exclusions Disabled ---")
+        print(page.extract_text(apply_exclusions=False))
+
+
+def example_pdf_level_exclusion(pdf_path):
+    """
+    Example demonstrating PDF-level exclusion zones with lambdas.
+    """
+    with PDF(pdf_path) as pdf:
+        # Print text from the first page for comparison
+        print("\n=== Original Text from First Page ===")
+        print(pdf.pages[0].extract_text(apply_exclusions=False)[:200] + "...")
+        
+        # Define safer exclusion functions with better error handling
+        def header_exclusion(page):
+            try:
+                header = page.find('text:contains("Page")')
+                if header:
+                    return header.above()
+                print(f"Page {page.index}: No 'Page' text found for header exclusion")
+                return None
+            except Exception as e:
+                print(f"ERROR in header exclusion for page {page.index}: {e}")
+                return None
+                
+        def footer_exclusion(page):
+            try:
+                lines = page.find_all('line')
+                if lines and len(lines) > 0:
+                    return lines[-1].below()
+                print(f"Page {page.index}: No lines found for footer exclusion")
+                return None
+            except Exception as e:
+                print(f"ERROR in footer exclusion for page {page.index}: {e}")
+                return None
+        
+        # Add document-wide exclusions using our safer functions
+        # 1. Exclude headers - find text containing "Page" and exclude everything above it
+        pdf.add_exclusion(header_exclusion, label="headers")
+        
+        # 2. Exclude footers - find the last line and exclude everything below it
+        pdf.add_exclusion(footer_exclusion, label="footers")
+        
+        # Print the cleaned text
+        print("\n=== Cleaned Text from First Page ===")
+        print(pdf.pages[0].extract_text()[:200] + "...")
+        
+        # Extract text from entire document with exclusions applied - WITH DEBUG INFORMATION
+        print("\n=== Extracting from Entire Document with Exclusions ===")
+        print("\n--- DETAILED DEBUG INFO ---")
+        full_text = pdf.extract_text(debug_exclusions=True)  # Enable detailed debugging
+        print("--- END OF DEBUG INFO ---\n")
+        
+        print(f"Extracted {len(full_text)} characters with exclusions applied")
+        print(full_text[:200] + "...")
+        
+        # Regular extraction (for comparison)
+        print("\n=== Regular Extraction Without Debug Info ===")
+        full_text_no_debug = pdf.extract_text()
+        print(f"Extracted {len(full_text_no_debug)} characters without debug output")
+        
+        # Extract text with exclusions disabled (for comparison)
+        print("\n=== Extracting with Exclusions Disabled (for comparison) ===")
+        full_text_no_exclusions = pdf.extract_text(apply_exclusions=False)
+        print(f"Extracted {len(full_text_no_exclusions)} characters with exclusions disabled")
+        if len(full_text) != len(full_text_no_exclusions):
+            print(f"Difference: {len(full_text_no_exclusions) - len(full_text)} characters were excluded")
+
+
+def main():
+    """Main entry point."""
+    # Get the PDF path from command line or use a default
+    if len(sys.argv) > 1:
+        pdf_path = sys.argv[1]
+    else:
+        # Look for any PDF in the examples directory or pdfs directory
+        example_dir = Path(__file__).parent
+        pdf_files = list(example_dir.glob("*.pdf"))
+        
+        if not pdf_files:
+            pdfs_dir = example_dir.parent / "pdfs"
+            if pdfs_dir.exists():
+                pdf_files = list(pdfs_dir.glob("*.pdf"))
+        
+        if pdf_files:
+            pdf_path = str(pdf_files[0])
+        else:
+            print("No PDF file found. Please provide a path to a PDF file.")
+            sys.exit(1)
+    
+    print(f"Using PDF: {pdf_path}")
+    
+    # Run the page-level example
+    print("\n=== Page-Level Exclusion Example ===")
+    example_page_level_exclusion(pdf_path)
+    
+    # Run the PDF-level example
+    print("\n=== PDF-Level Exclusion Example ===")
+    example_pdf_level_exclusion(pdf_path)
+
+
+if __name__ == "__main__":
+    main()