natural-pdf 25.3.16__py3-none-any.whl

examples/exclusion_optimization_example.py

@@ -0,0 +1,190 @@
+"""
+Example demonstrating the optimized exclusion handling for various region types.
+"""
+
+import os
+import sys
+from pathlib import Path
+import time
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from natural_pdf import PDF
+
+
+def measure_time(func):
+    """Decorator to measure function execution time."""
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        print(f"Time taken: {end_time - start_time:.4f} seconds")
+        return result
+    return wrapper
+
+
+def optimized_exclusion_example(pdf_path):
+    """
+    Demonstrates the optimized exclusion handling for different region types.
+    """
+    with PDF(pdf_path) as pdf:
+        page = pdf.pages[0]
+        print(f"Using PDF: {pdf_path}")
+        
+        # Create an output directory
+        output_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'output'))
+        os.makedirs(output_dir, exist_ok=True)
+        
+        # Step 1: Set up exclusion zones
+        print("\n=== Setting Up Exclusion Zones ===")
+        # Top 10% of page as header
+        header_zone = page.create_region(0, 0, page.width, page.height * 0.1)
+        header_zone.highlight(label="Header Exclusion", color=(1, 0, 0, 0.3))
+        page.add_exclusion(header_zone)
+        
+        # Bottom 10% of page as footer
+        footer_zone = page.create_region(0, page.height * 0.9, page.width, page.height)
+        footer_zone.highlight(label="Footer Exclusion", color=(0, 0, 1, 0.3))
+        page.add_exclusion(footer_zone)
+        
+        # Left 20% as a side panel (complex exclusion)
+        side_panel = page.create_region(0, 0, page.width * 0.2, page.height)
+        side_panel.highlight(label="Side Panel Exclusion", color=(0, 1, 0, 0.3))
+        page.add_exclusion(side_panel)
+        
+        print(f"Added 3 exclusion zones: header, footer, and side panel")
+        
+        # Step 2: Create test regions of different types
+        print("\n=== Creating Test Regions ===")
+        # Non-intersecting region (in center, away from all exclusions)
+        non_intersecting = page.create_region(
+            page.width * 0.3, 
+            page.height * 0.3, 
+            page.width * 0.8, 
+            page.height * 0.7
+        )
+        non_intersecting.highlight(label="Non-Intersecting Region", color=(1, 1, 0, 0.3))
+        
+        # Header/footer-only region (full width but between exclusions)
+        header_footer_region = page.create_region(
+            0,
+            0,
+            page.width,
+            page.height
+        )
+        header_footer_region.highlight(label="Full Page Region", color=(1, 0, 1, 0.2))
+        
+        # Complex region (intersects with side panel)
+        complex_region = page.create_region(
+            0,
+            page.height * 0.2,
+            page.width * 0.5,
+            page.height * 0.8
+        )
+        complex_region.highlight(label="Complex Region", color=(0, 1, 1, 0.3))
+        
+        print("Created 3 test regions with different exclusion intersection patterns")
+        
+        # Save the visualization
+        output_file = os.path.join(output_dir, "exclusion_optimization_regions.png")
+        page.save_image(output_file, labels=True)
+        print(f"Saved visualization to: {output_file}")
+        
+        # Step 3: Test extraction with and without optimizations
+        print("\n=== Testing Text Extraction with Exclusions ===")
+        
+        # Test non-intersecting region
+        print("\nNon-Intersecting Region:")
+        print("This region should use the fast path (no exclusion checking)")
+        print("Extracting text with apply_exclusions=True...")
+        
+        @measure_time
+        def extract_non_intersecting():
+            return non_intersecting.extract_text(apply_exclusions=True)
+        
+        text1 = extract_non_intersecting()
+        
+        print("Extracting text with apply_exclusions=False (for comparison)...")
+        
+        @measure_time
+        def extract_non_intersecting_no_exclusions():
+            return non_intersecting.extract_text(apply_exclusions=False)
+        
+        text2 = extract_non_intersecting_no_exclusions()
+        
+        print(f"Text length comparison: with exclusions={len(text1)}, without={len(text2)}")
+        print(f"Identical results: {text1 == text2}")
+        
+        # Test header/footer region
+        print("\nFull Page Region (intersecting header/footer):")
+        print("This region should use cropping optimization for header/footer exclusions")
+        print("Extracting text with apply_exclusions=True...")
+        
+        @measure_time
+        def extract_header_footer():
+            return header_footer_region.extract_text(apply_exclusions=True)
+        
+        text3 = extract_header_footer()
+        
+        print("Extracting text with apply_exclusions=False (for comparison)...")
+        
+        @measure_time
+        def extract_header_footer_no_exclusions():
+            return header_footer_region.extract_text(apply_exclusions=False)
+        
+        text4 = extract_header_footer_no_exclusions()
+        
+        print(f"Text length comparison: with exclusions={len(text3)}, without={len(text4)}")
+        print(f"Header/footer content excluded: {len(text4) > len(text3)}")
+        
+        # Test complex region
+        print("\nComplex Region (intersecting side panel):")
+        print("This region should use filtering with warning")
+        print("Extracting text with apply_exclusions=True...")
+        
+        @measure_time
+        def extract_complex():
+            return complex_region.extract_text(apply_exclusions=True)
+        
+        text5 = extract_complex()
+        
+        print("Extracting text with apply_exclusions=False (for comparison)...")
+        
+        @measure_time
+        def extract_complex_no_exclusions():
+            return complex_region.extract_text(apply_exclusions=False)
+        
+        text6 = extract_complex_no_exclusions()
+        
+        print(f"Text length comparison: with exclusions={len(text5)}, without={len(text6)}")
+        
+        # Step 4: Summarize findings
+        print("\n=== Summary ===")
+        print("1. Non-intersecting region: Optimization should skip exclusion checks entirely")
+        print("2. Header/footer region: Optimization should use direct cropping")
+        print("3. Complex region: Falls back to filtering with warning")
+        print("\nCheck the produced warning messages to confirm the behavior.")
+        
+
+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 pdfs directory
+        pdfs_dir = Path(__file__).parent.parent / "pdfs"
+        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)
+    
+    optimized_exclusion_example(pdf_path)
+
+
+if __name__ == "__main__":
+    main()

examples/extract_text_test.py

@@ -0,0 +1,128 @@
+"""
+Test script for the new extract_text implementation that uses pdfplumber's native functionality.
+"""
+
+import os
+import sys
+from io import StringIO
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), "..")))
+
+from natural_pdf import PDF
+import time
+
+def main():
+    # Use a sample PDF
+    pdf_path = "pdfs/01-practice.pdf"
+    if len(sys.argv) > 1:
+        pdf_path = sys.argv[1]
+    
+    # Load the PDF
+    pdf = PDF(pdf_path)
+    page = pdf.pages[0]
+    
+    print(f"Loaded {pdf_path}, processing first page...")
+    
+    # Create different regions
+    full_region = page.create_region(0, 0, page.width, page.height)
+    top_region = page.create_region(0, 0, page.width, page.height / 3)
+    bottom_region = page.create_region(0, page.height * 2/3, page.width, page.height)
+    
+    # Create a non-rectangular region (a triangle)
+    # First create the region with a bbox
+    triangle_region = page.create_region(0, 0, page.width, page.height/2)
+    # Then set the polygon directly
+    triangle_region._polygon = [(0, 0), (page.width, 0), (page.width/2, page.height/2)]
+    
+    # Add an exclusion region
+    page.add_exclusion(bottom_region)
+    
+    # Test extraction with different settings
+    
+    # 1. Standard rectangular region without exclusions
+    print("\nExtracting text from top region:")
+    start = time.time()
+    # First try with just crop to debug - use bbox directly
+    crop_bbox = top_region.bbox
+    
+    print(f"Using bbox: {crop_bbox}")
+    
+    cropped = page._page.crop(crop_bbox)
+    direct_text = cropped.extract_text(keep_blank_chars=True)
+    print(f"Direct crop text length: {len(direct_text)}, Text: {direct_text[:100]}")
+    
+    # Check if there's a bug when passing the instance directly to extract_text
+    print("Converting region to a dictionary and creating a new Region")
+    region_dict = {
+        'x0': top_region.x0,
+        'top': top_region.top,
+        'x1': top_region.x1, 
+        'bottom': top_region.bottom
+    }
+    bbox = (region_dict['x0'], region_dict['top'], region_dict['x1'], region_dict['bottom'])
+    
+    from natural_pdf.elements.region import Region
+    test_region = Region(page, bbox)
+    print(f"New region bbox: {test_region.bbox}")
+    
+    # Create a simple direct call to pdfplumber's crop
+    print("Testing direct pdfplumber crop and extract:")
+    crop_bbox = test_region.bbox
+    cropped_page = page._page.crop(crop_bbox)
+    print(f"Cropped page dimensions: {cropped_page.width} × {cropped_page.height}")
+    print(f"Cropped page characters: {len(cropped_page.chars)}")
+    if cropped_page.chars:
+        print(f"First few chars: {cropped_page.chars[:3]}")
+    direct_crop_text = cropped_page.extract_text(keep_blank_chars=True)
+    print(f"Direct pdfplumber extraction: {len(direct_crop_text)} chars")
+    print(direct_crop_text[:100])
+    
+    # Test if we're seeing any print outputs from extract_text
+    original_stderr = sys.stderr
+    string_stderr = StringIO()
+    sys.stderr = string_stderr
+    
+    # Try the new region's extract_text
+    text = test_region.extract_text(keep_blank_chars=True)
+    stderr_output = string_stderr.getvalue()
+    sys.stderr = original_stderr
+    
+    print(f"Stderr output from extract_text call:\n{stderr_output}")
+    
+    elapsed = time.time() - start
+    print(f"Length: {len(text)} characters, Time: {elapsed:.4f} seconds")
+    print(text[:200] + "..." if len(text) > 200 else text)
+    
+    # 2. Full page with exclusions
+    print("\nExtracting text from full page with exclusions:")
+    start = time.time()
+    text = full_region.extract_text(apply_exclusions=True)
+    elapsed = time.time() - start
+    print(f"Length: {len(text)} characters, Time: {elapsed:.4f} seconds")
+    print(text[:200] + "..." if len(text) > 200 else text)
+    
+    # 3. Polygon region (triangle)
+    print("\nExtracting text from triangle region:")
+    start = time.time()
+    text = triangle_region.extract_text()
+    elapsed = time.time() - start
+    print(f"Length: {len(text)} characters, Time: {elapsed:.4f} seconds")
+    print(text[:200] + "..." if len(text) > 200 else text)
+    
+    # 4. With OCR option (to test that pathway)
+    print("\nExtracting text with OCR option:")
+    start = time.time()
+    text = top_region.extract_text(ocr={"enabled": True})
+    elapsed = time.time() - start
+    print(f"Length: {len(text)} characters, Time: {elapsed:.4f} seconds")
+    print(text[:200] + "..." if len(text) > 200 else text)
+    
+    # For comparison, test the regular page.extract_text method
+    print("\nExtraction with page.extract_text for comparison:")
+    start = time.time()
+    text = page.extract_text(preserve_whitespace=True, apply_exclusions=True)
+    elapsed = time.time() - start
+    print(f"Length: {len(text)} characters, Time: {elapsed:.4f} seconds")
+    print(text[:200] + "..." if len(text) > 200 else text)
+
+if __name__ == "__main__":
+    main()

examples/font_aware_example.py

@@ -0,0 +1,101 @@
+"""
+Example demonstrating font-aware text extraction in Natural PDF.
+
+This example shows how to use the font_attrs parameter to group text by font properties,
+which helps preserve the formatting and style of text during extraction.
+"""
+import os
+import sys
+
+# Add the parent directory to the path so we can import natural_pdf module
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from natural_pdf import PDF
+
+def main():
+    # If a PDF path is provided, use it; otherwise use the default example
+    if len(sys.argv) > 1:
+        pdf_path = sys.argv[1]
+    else:
+        # Use a default PDF path - you'll need to replace this with an actual PDF path
+        pdf_path = "examples/sample.pdf"
+        if not os.path.exists(pdf_path):
+            print(f"Default PDF not found at {pdf_path}")
+            print("Please provide a PDF path as an argument")
+            return
+    
+    print(f"Processing PDF: {pdf_path}")
+    
+    # Example 1: Default behavior - group by fontname and size
+    print("\n1. Default behavior (group by fontname and size):")
+    pdf = PDF(pdf_path)
+    page = pdf.pages[0]
+    
+    # Find some text element to inspect
+    text_element = page.find("text")
+    if text_element:
+        print(f"Example text element: {text_element}")
+        print(f"Font info: {text_element.font_info()}")
+    
+    # Example 2: Disable font-aware grouping
+    print("\n2. Disable font-aware grouping (spatial only):")
+    pdf_no_font = PDF(pdf_path, font_attrs=[])
+    page_no_font = pdf_no_font.pages[0]
+    
+    # Find the same text with different grouping
+    text_element = page_no_font.find("text")
+    if text_element:
+        print(f"Example text element: {text_element}")
+    
+    # Example 3: Group by additional attributes
+    print("\n3. Group by font and color:")
+    pdf_with_color = PDF(pdf_path, font_attrs=['fontname', 'size', 'non_stroking_color'])
+    page_with_color = pdf_with_color.pages[0]
+    
+    # Find the same text with color grouping
+    text_element = page_with_color.find("text")
+    if text_element:
+        print(f"Example text element: {text_element}")
+    
+    # Compare text extraction results
+    print("\n4. Text extraction comparison:")
+    
+    # Get a small region with mixed text styles
+    text_elements = page.find_all("text")
+    if text_elements:
+        region = page.create_region(0, 0, page.width, page.height)  # Use the full page
+        
+        # Extract with different font grouping settings
+        default_text = region.extract_text()
+        spatial_text = page_no_font.create_region(0, 0, page_no_font.width, page_no_font.height).extract_text()
+        color_text = page_with_color.create_region(0, 0, page_with_color.width, page_with_color.height).extract_text()
+        
+        # Show word counts as a simple comparison
+        print(f"Default grouping word count: {len(default_text.split())}")
+        print(f"Spatial-only grouping word count: {len(spatial_text.split())}")
+        print(f"Font+color grouping word count: {len(color_text.split())}")
+        
+        # Show sample of text differences
+        print("\nText samples (first 200 chars):")
+        print(f"Default: {default_text[:200]}...")
+        print(f"Spatial: {spatial_text[:200]}...")
+        print(f"Color-aware: {color_text[:200]}...")
+    
+    # Example 4: Detailed character-level analysis
+    print("\n5. Character-level analysis:")
+    
+    # Get raw character data
+    chars = page.find_all('char')[:5]  # First 5 characters
+    print(f"Raw character elements ({len(chars)} of {len(page.find_all('char'))} total):")
+    for char in chars:
+        print(f" - {char}")
+    
+    # Show word elements too
+    words = page.find_all("text")[:3]  # First 3 words
+    print(f"\nWord elements ({len(words)} of {len(page.find_all('text'))} total):")
+    for word in words:
+        print(f" - {word}")
+        print(f"   Font info: {word.font_info()}")
+
+if __name__ == "__main__":
+    main()

examples/font_variant_example.py

@@ -0,0 +1,124 @@
+"""
+Example demonstrating font variant detection in Natural PDF.
+
+This example shows how to identify and filter text elements by font variant
+(the prefix in embedded font names, such as 'AAAAAB+FontName').
+"""
+import os
+import sys
+
+# Add the parent directory to the path so we can import natural_pdf module
+sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from natural_pdf import PDF
+
+def main():
+    # If a PDF path is provided, use it; otherwise use the default example
+    if len(sys.argv) > 1:
+        pdf_path = sys.argv[1]
+    else:
+        # Use a default PDF path - you'll need to replace this with an actual PDF path
+        pdf_path = "examples/sample.pdf"
+        if not os.path.exists(pdf_path):
+            print(f"Default PDF not found at {pdf_path}")
+            print("Please provide a PDF path as an argument")
+            return
+    
+    print(f"Processing PDF: {pdf_path}")
+    pdf = PDF(pdf_path)
+    page = pdf.pages[0]
+    
+    # Example 1: Identify different font variants on the page
+    print("\n1. Identifying font variants")
+    
+    # Get all text elements
+    all_text = page.find_all('text')
+    
+    # Collect unique font variants
+    variants = {}
+    for element in all_text:
+        variant = element.font_variant
+        if variant:
+            if variant not in variants:
+                variants[variant] = {
+                    'count': 0,
+                    'example': element.text,
+                    'fontname': element.fontname
+                }
+            variants[variant]['count'] += 1
+    
+    # Display the variants found
+    print(f"Found {len(variants)} font variants on the page:")
+    for variant, info in variants.items():
+        print(f"  Variant: '{variant}'")
+        print(f"    Full fontname: {info['fontname']}")
+        print(f"    Count: {info['count']} elements")
+        print(f"    Example text: '{info['example']}'")
+    
+    # Example 2: Filter elements by font variant
+    print("\n2. Filtering by font variant")
+    
+    # Select a variant to filter by (use the first one found)
+    if variants:
+        target_variant = next(iter(variants.keys()))
+        print(f"Filtering for variant: '{target_variant}'")
+        
+        # Filter elements with this variant
+        variant_elements = page.find_all(f'text[font-variant="{target_variant}"]')
+        print(f"Found {len(variant_elements)} elements with this variant")
+        
+        # Display some examples
+        for i, element in enumerate(variant_elements[:5]):
+            print(f"  Element {i+1}: '{element.text}'")
+            if i >= 4:
+                break
+                
+        # Example 3: Compare visually similar texts with different variants
+        print("\n3. Visual comparison of variants")
+        
+        # Find all variants
+        variant_list = list(variants.keys())
+        
+        # If we have multiple variants, compare them
+        if len(variant_list) >= 2:
+            variant_1 = variant_list[0]
+            variant_2 = variant_list[1]
+            
+            print(f"Comparing variant '{variant_1}' with '{variant_2}':")
+            
+            # Get elements from each variant
+            elements_1 = page.find_all(f'text[font-variant="{variant_1}"]')
+            elements_2 = page.find_all(f'text[font-variant="{variant_2}"]')
+            
+            # Highlight elements with different colors
+            if elements_1:
+                elements_1.highlight(color=(1, 0, 0), label=f"Variant {variant_1}")
+            if elements_2:
+                elements_2.highlight(color=(0, 1, 0), label=f"Variant {variant_2}")
+                
+            # Save the highlighted page
+            highlight_path = "font_variants_highlight.png"
+            page.save(highlight_path, labels=True)
+            print(f"Highlighted comparison saved to {highlight_path}")
+            
+            # Compare properties of elements from each variant
+            if elements_1 and elements_2:
+                elem1 = elements_1[0]
+                elem2 = elements_2[0]
+                
+                print("\nDetailed comparison of first elements from each variant:")
+                
+                # Print font info for each
+                print(f"\nVariant '{variant_1}' font info:")
+                for k, v in elem1.font_info().items():
+                    print(f"  {k}: {v}")
+                    
+                print(f"\nVariant '{variant_2}' font info:")
+                for k, v in elem2.font_info().items():
+                    print(f"  {k}: {v}")
+        
+    else:
+        print("No font variants found to filter by")
+
+if __name__ == "__main__":
+    main()

examples/footer_overlap_test.py

@@ -0,0 +1,124 @@
+"""
+Test for handling regions that overlap with a footer exclusion zone.
+This is a focused test for the specific issue where regions that overlap with a footer
+weren't returning any text.
+"""
+
+import os
+import sys
+import logging
+from pathlib import Path
+
+# Configure logging
+import logging
+logging.basicConfig(level=logging.INFO)
+
+from natural_pdf import PDF
+
+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 pdfs directory
+        pdfs_dir = Path(__file__).parent.parent / "pdfs"
+        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"\nTesting with PDF: {pdf_path}")
+    
+    # Create a PDF object
+    pdf = PDF(pdf_path)
+    page = pdf.pages[0]
+    
+    # Create ONLY a footer exclusion zone
+    footer_height = page.height * 0.1  # Bottom 10% of the page
+    footer = page.create_region(0, page.height - footer_height, page.width, page.height)
+    footer.highlight(label="Footer Exclusion", color=(1, 0, 0, 0.3))
+    page.add_exclusion(footer)
+    print(f"Added footer exclusion: {footer.bbox}")
+    
+    # Create a region that extends from middle of page to past the footer
+    middle_to_footer = page.create_region(
+        page.width * 0.25,        # 25% from left
+        page.height * 0.5,        # 50% from top (middle of page)
+        page.width * 0.75,        # 75% from left
+        page.height               # All the way to bottom (overlaps footer)
+    )
+    middle_to_footer.highlight(label="Middle to Footer", color=(0, 1, 0, 0.3))
+    print(f"Created test region: {middle_to_footer.bbox}")
+    
+    # Try different extraction approaches:
+    
+    # 1. Extract with exclusions using the default approach
+    print("\n=== 1. Using Default Extraction ===")
+    text = middle_to_footer.extract_text(apply_exclusions=True, debug=True)
+    print(f"Text length: {len(text)}")
+    print(f"First 100 chars: {text[:100] if text else 'No text!'}")
+    
+    # 2. Try direct cropping approach
+    print("\n=== 2. Using Direct Crop Approach ===")
+    # Manually adjust the region to exclude the footer
+    top_bound = middle_to_footer.top
+    bottom_bound = page.height - footer_height  # Top of footer
+    
+    cropped_region = page.create_region(
+        middle_to_footer.x0,
+        top_bound,
+        middle_to_footer.x1,
+        bottom_bound
+    )
+    cropped_region.highlight(label="Cropped Region", color=(0, 0, 1, 0.3))
+    
+    # Extract without applying exclusions (since we manually cropped)
+    cropped_text = cropped_region.extract_text(apply_exclusions=False)
+    print(f"Text length: {len(cropped_text)}")
+    print(f"First 100 chars: {cropped_text[:100] if cropped_text else 'No text!'}")
+    
+    # 3. Get individual elements and extract text from them
+    print("\n=== 3. Using Element Filtering Approach ===")
+    all_elements = page.get_elements()
+    
+    # Filter elements that are in our region but NOT in footer
+    filtered_elements = []
+    for element in all_elements:
+        # Check if element is in the region
+        if (middle_to_footer.x0 <= (element.x0 + element.x1)/2 <= middle_to_footer.x1 and
+            middle_to_footer.top <= (element.top + element.bottom)/2 <= middle_to_footer.bottom and
+            not (footer.top <= (element.top + element.bottom)/2 <= footer.bottom)):
+            filtered_elements.append(element)
+    
+    # Extract text from the filtered elements
+    filtered_text = " ".join(e.text for e in filtered_elements if hasattr(e, 'text'))
+    print(f"Text length: {len(filtered_text)}")
+    print(f"First 100 chars: {filtered_text[:100] if filtered_text else 'No text!'}")
+    
+    # Save the visualization
+    page.save_image("output/footer_overlap_test.png", labels=True)
+    print(f"\nTest visualization saved to output/footer_overlap_test.png")
+    
+    # Provide a summary
+    print("\nTEST SUMMARY:")
+    if len(text) > 0:
+        print("✅ Default extraction works now with overlapping exclusions!")
+    else:
+        print("❌ Default extraction still fails with overlapping exclusions!")
+    
+    if len(cropped_text) > 0:
+        print("✅ Manual cropping approach works!")
+    else:
+        print("❌ Manual cropping approach fails!")
+    
+    if len(filtered_text) > 0:
+        print("✅ Element filtering approach works!")
+    else:
+        print("❌ Element filtering approach fails!")
+
+if __name__ == "__main__":
+    main()