⚡️ Speed up function get_bbox_span_subset by 306%

[codeflash-ai]

📄 306% (3.06x) speedup for get_bbox_span_subset in unstructured_inference/models/table_postprocess.py

⏱️ Runtime : 9.24 milliseconds → 2.28 milliseconds (best of 115 runs)

📝 Explanation and details

The optimized code achieves a 305% speedup (9.24ms → 2.28ms) by eliminating expensive object allocations and method calls that dominated the original implementation.

Key Optimizations

1. Eliminated Rect Object Construction (67.8% → 0% of overlaps() time)

• The original code created Rect objects via Rect(list(bbox1)) and Rect(list(bbox2)), which involved:
  • Two list() calls to copy sequences
  • Object instantiation overhead
  • Attribute assignments in __init__
• The optimized version directly indexes into bbox coordinates (bbox1[0], bbox1[1], etc.), avoiding all allocations

2. Inlined Intersection Area Calculation

• Original: rect1.intersect(other).get_area() required method calls and state mutations
• Optimized: Direct arithmetic with conditional logic computes intersection area inline
• Eliminates method call overhead and intermediate object state changes

3. List Comprehension in get_bbox_span_subset()

• Replaced explicit loop + append pattern with list comprehension
• Reduces Python-level loop overhead and function call overhead for list.append()
• Comprehensions are optimized at the C level in CPython

Performance Impact by Test Case

The optimization shows ~2-3.5x speedup across all test patterns:

• Simple cases (single spans): ~110-125% faster (8-9μs → 3-4μs)
• Large-scale tests (100-1000 spans): ~300-350% faster (150-3000μs → 40-770μs)
• Zero-area edge cases benefit most: up to 149% faster due to early exit efficiency

Context from Function References

The function extract_text_inside_bbox() calls get_bbox_span_subset() in what appears to be a text extraction pipeline. Given this is table postprocessing code (Microsoft Table Transformer), this likely runs on every table cell or region during document analysis. The optimization is particularly valuable because:

• Table extraction processes many bounding boxes per page
• Each bbox may be checked against hundreds of text spans
• The cumulative effect of 3-4x speedup per call becomes significant in production workloads

Why It Works

The line profiler shows the original overlaps() spent 67.8% of time in rect1.intersect(Rect(list(bbox2))).get_area(). By replacing object-oriented abstractions with direct arithmetic, the optimized version distributes work across simple operations (indexing, comparisons, arithmetic) that execute much faster than object construction and method dispatch in Python.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 52 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

import pytest  # used for our unit tests
from unstructured_inference.models.table_postprocess import \
    get_bbox_span_subset

def test_single_span_fully_inside_default_threshold():
    # A single span entirely inside the bbox should be returned (default threshold 0.5).
    span = {"bbox": [1, 1, 4, 4]}  # area = 9
    bbox = [0, 0, 10, 10]  # large bbox containing the span entirely
    codeflash_output = get_bbox_span_subset([span], bbox); result = codeflash_output # 8.25μs -> 3.73μs (121% faster)

def test_partial_overlap_less_than_threshold_excluded():
    # Span overlaps bbox by 40% -> for default threshold 0.5 it should be excluded.
    span = {"bbox": [0, 0, 10, 10]}  # area = 100
    bbox = [0, 0, 4, 10]  # intersection area = 4*10 = 40 -> ratio = 0.4
    codeflash_output = get_bbox_span_subset([span], bbox); result = codeflash_output # 8.25μs -> 3.68μs (124% faster)

def test_exact_threshold_included():
    # Span overlaps bbox by exactly 50% -> ratio == threshold -> should be included.
    span = {"bbox": [0, 0, 10, 10]}  # area = 100
    bbox = [0, 0, 5, 10]  # intersection area = 50 -> ratio = 0.5
    codeflash_output = get_bbox_span_subset([span], bbox, threshold=0.5); result = codeflash_output # 8.85μs -> 4.08μs (117% faster)

def test_zero_area_span_is_excluded():
    # A span with zero area (zero width) should be excluded immediately.
    span_zero_area = {"bbox": [1, 1, 1, 5]}  # width = 0 -> area = 0
    bbox = [0, 0, 10, 10]
    codeflash_output = get_bbox_span_subset([span_zero_area], bbox); result = codeflash_output # 4.00μs -> 2.61μs (53.4% faster)

def test_bbox_zero_area_excludes_span():
    # If bbox has zero area, intersection area will be zero -> not meeting positive threshold.
    span = {"bbox": [0, 0, 10, 10]}  # area = 100
    bbox_zero = [5, 5, 5, 5]  # bbox2 area = 0
    codeflash_output = get_bbox_span_subset([span], bbox_zero, threshold=0.0); result = codeflash_output # 9.22μs -> 4.17μs (121% faster)
    # Note: for threshold == 0.0 the implementation treats zero intersection as >= 0.
    # But since bbox2 area is zero, intersection area is zero and ratio 0 >= 0 -> True.
    # However overlaps() first checks area1 (span area) which is nonzero, then computes ratio.
    # Thus with threshold 0.0 it will include the span; with threshold>0 it excludes.
    codeflash_output = get_bbox_span_subset([span], bbox_zero, threshold=0.0) # 5.23μs -> 2.22μs (135% faster)
    codeflash_output = get_bbox_span_subset([span], bbox_zero, threshold=0.1) # 4.40μs -> 1.77μs (149% faster)

def test_touching_edge_counts_as_no_overlap_for_default_threshold():
    # Two rectangles that touch at an edge have zero-area intersection -> excluded.
    span = {"bbox": [0, 0, 10, 10]}
    bbox_touch = [10, 0, 20, 10]  # touches at x=10 line -> intersection area = 0
    codeflash_output = get_bbox_span_subset([span], bbox_touch); result = codeflash_output # 8.97μs -> 3.72μs (141% faster)

def test_threshold_zero_includes_disjoint_spans_due_to_implementation():
    # According to current implementation, threshold == 0 allows even zero-overlap spans.
    span = {"bbox": [0, 0, 10, 10]}
    bbox_disjoint = [20, 20, 30, 30]  # completely disjoint
    # With threshold 0, overlaps() computes 0 / area1 >= 0 -> True, so span is included.
    codeflash_output = get_bbox_span_subset([span], bbox_disjoint, threshold=0.0); result = codeflash_output # 8.73μs -> 3.96μs (121% faster)

def test_threshold_very_small_excludes_disjoint_spans():
    # With a tiny positive threshold, disjoint spans should be excluded.
    span = {"bbox": [0, 0, 10, 10]}
    bbox_disjoint = [20, 20, 30, 30]  # no intersection
    codeflash_output = get_bbox_span_subset([span], bbox_disjoint, threshold=1e-9); result = codeflash_output # 8.55μs -> 3.84μs (122% faster)

def test_negative_coordinates_and_exact_ratio():
    # Negative coordinates supported; prepare a case with exact fractional overlap.
    span = {"bbox": [-10, -10, 0, 0]}  # area = 100
    bbox = [-5, -5, 5, 5]  # intersection with span is [-5,-5,0,0] area = 25 -> ratio = 0.25
    # threshold exactly 0.25 -> should be included (>=)
    codeflash_output = get_bbox_span_subset([span], bbox, threshold=0.25); result = codeflash_output # 8.60μs -> 3.98μs (116% faster)
    # threshold slightly above -> excluded
    codeflash_output = get_bbox_span_subset([span], bbox, threshold=0.2500001) # 4.71μs -> 2.17μs (117% faster)

def test_large_scale_alternating_spans_selection():
    # Create a large but bounded list of spans (500 elements),
    # alternating between spans that are inside the bbox and spans that are outside.
    spans = []
    inside_bbox = [0, 0, 100, 100]
    # Construct deterministic spans: even indices are inside (10,10,20,20),
    # odd indices are far outside (200,200,210,210).
    total = 500  # well under the 1000-element instruction
    for i in range(total):
        if i % 2 == 0:
            spans.append({"bbox": [10, 10, 20, 20], "idx": i})  # fully inside
        else:
            spans.append({"bbox": [200, 200, 210, 210], "idx": i})  # fully outside

    # Use default threshold 0.5 (but inside spans are entirely inside -> included)
    codeflash_output = get_bbox_span_subset(spans, inside_bbox); subset = codeflash_output # 1.51ms -> 350μs (332% faster)

    # Verify that all returned spans are the even-indexed ones and in the original order.
    expected = [s for s in spans if s["idx"] % 2 == 0]

def test_preserves_order_and_returns_copies_of_same_objects():
    # Ensure that the function preserves iteration order and returns the same span objects
    # (not copies) by checking identity.
    s1 = {"bbox": [0, 0, 2, 2], "name": "a"}  # small square
    s2 = {"bbox": [5, 5, 8, 8], "name": "b"}  # outside for the bbox below
    s3 = {"bbox": [1, 1, 3, 3], "name": "c"}  # overlaps with first when bbox is [0,0,3,3]
    spans = [s1, s2, s3]
    bbox = [0, 0, 3, 3]
    codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.1); subset = codeflash_output # 16.8μs -> 6.51μs (159% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import pytest
from unstructured_inference.models.table_postprocess import (
    Rect, get_bbox_span_subset, overlaps)

class TestGetBboxSpanSubsetBasic:
    """Basic test cases for get_bbox_span_subset function"""

    def test_empty_spans_list(self):
        """Test with an empty spans list - should return empty list"""
        spans = []
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox); result = codeflash_output # 745ns -> 1.42μs (47.4% slower)

    def test_single_span_fully_overlapping(self):
        """Test with a single span that fully overlaps with bbox"""
        spans = [{"bbox": [10, 10, 50, 50], "text": "hello"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.77μs -> 4.07μs (116% faster)

    def test_single_span_no_overlap(self):
        """Test with a single span that doesn't overlap with bbox"""
        spans = [{"bbox": [200, 200, 300, 300], "text": "world"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.67μs -> 3.83μs (127% faster)

    def test_multiple_spans_mixed_overlap(self):
        """Test with multiple spans, some overlapping and some not"""
        spans = [
            {"bbox": [10, 10, 50, 50], "text": "first"},
            {"bbox": [200, 200, 300, 300], "text": "second"},
            {"bbox": [40, 40, 80, 80], "text": "third"},
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 16.6μs -> 6.53μs (154% faster)
        texts = [span["text"] for span in result]

    def test_span_with_zero_area_bbox(self):
        """Test with a span that has zero area bbox (point)"""
        spans = [{"bbox": [50, 50, 50, 50], "text": "point"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 4.20μs -> 2.86μs (46.8% faster)

    def test_query_bbox_with_zero_area(self):
        """Test when the query bbox has zero area"""
        spans = [{"bbox": [10, 10, 50, 50], "text": "span"}]
        bbox = [50, 50, 50, 50]  # Zero area bbox
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 9.13μs -> 4.03μs (127% faster)

    def test_threshold_zero(self):
        """Test with threshold=0.0 - any overlap should include the span"""
        spans = [{"bbox": [95, 95, 105, 105], "text": "corner"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.0); result = codeflash_output # 8.54μs -> 4.09μs (109% faster)

    def test_threshold_one(self):
        """Test with threshold=1.0 - entire span must be within bbox"""
        spans = [
            {"bbox": [10, 10, 50, 50], "text": "inside"},
            {"bbox": [90, 90, 110, 110], "text": "partial"},
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=1.0); result = codeflash_output # 12.7μs -> 5.26μs (142% faster)

    def test_identical_bboxes(self):
        """Test when span bbox is identical to query bbox"""
        spans = [{"bbox": [10, 20, 30, 40], "text": "exact"}]
        bbox = [10, 20, 30, 40]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.71μs -> 3.94μs (121% faster)

    def test_span_attributes_preserved(self):
        """Test that all span attributes are preserved in result"""
        spans = [
            {
                "bbox": [10, 10, 50, 50],
                "text": "hello",
                "confidence": 0.95,
                "id": 42,
            }
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox); result = codeflash_output # 8.37μs -> 3.73μs (124% faster)

class TestGetBboxSpanSubsetEdgeCases:
    """Edge case tests for get_bbox_span_subset function"""

    def test_span_at_bbox_boundary_top_left(self):
        """Test span starting at bbox top-left corner"""
        spans = [{"bbox": [0, 0, 50, 50], "text": "corner"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.71μs -> 4.05μs (115% faster)

    def test_span_at_bbox_boundary_bottom_right(self):
        """Test span ending at bbox bottom-right corner"""
        spans = [{"bbox": [50, 50, 100, 100], "text": "corner"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.50μs -> 4.04μs (110% faster)

    def test_span_slightly_outside_bbox(self):
        """Test span that slightly extends outside bbox"""
        spans = [{"bbox": [90, 90, 110, 110], "text": "outside"}]
        bbox = [0, 0, 100, 100]
        # The intersection is a 10x10 square (area=100)
        # The span is 20x20 (area=400)
        # Overlap fraction is 100/400 = 0.25, which is < 0.5
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.56μs -> 4.05μs (112% faster)

    def test_span_with_negative_coordinates(self):
        """Test span with negative bbox coordinates"""
        spans = [{"bbox": [-50, -50, 50, 50], "text": "negative"}]
        bbox = [0, 0, 100, 100]
        # Intersection is [0, 0, 50, 50], area = 2500
        # Span area is 100*100 = 10000
        # Overlap = 2500/10000 = 0.25 < 0.5
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.59μs -> 4.12μs (108% faster)

    def test_very_small_span(self):
        """Test with very small span bbox"""
        spans = [{"bbox": [50, 50, 50.1, 50.1], "text": "tiny"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 9.24μs -> 4.49μs (106% faster)

    def test_very_large_span(self):
        """Test with very large span bbox"""
        spans = [{"bbox": [-1000, -1000, 2000, 2000], "text": "huge"}]
        bbox = [0, 0, 100, 100]
        # The entire bbox is within the span, so overlap is 100%
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.71μs -> 4.15μs (110% faster)

    def test_span_crosses_bbox_horizontally(self):
        """Test span that crosses bbox horizontally"""
        spans = [{"bbox": [40, 40, 60, 60], "text": "cross"}]
        bbox = [0, 0, 50, 100]
        # Intersection is [40, 40, 50, 60], area = 10*20 = 200
        # Span area is 20*20 = 400
        # Overlap = 200/400 = 0.5 (exactly at threshold)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.77μs -> 4.11μs (114% faster)

    def test_span_crosses_bbox_vertically(self):
        """Test span that crosses bbox vertically"""
        spans = [{"bbox": [40, 40, 60, 60], "text": "cross"}]
        bbox = [0, 0, 100, 50]
        # Intersection is [40, 40, 60, 50], area = 20*10 = 200
        # Span area is 20*20 = 400
        # Overlap = 200/400 = 0.5 (exactly at threshold)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.76μs -> 3.94μs (122% faster)

    def test_multiple_spans_same_bbox(self):
        """Test multiple spans with identical bboxes"""
        spans = [
            {"bbox": [10, 10, 50, 50], "text": "first"},
            {"bbox": [10, 10, 50, 50], "text": "second"},
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox); result = codeflash_output # 12.0μs -> 4.98μs (141% faster)

    def test_threshold_between_zero_and_one(self):
        """Test with threshold between 0 and 1"""
        # Create span where overlap is exactly 0.75
        spans = [{"bbox": [75, 0, 125, 100], "text": "test"}]
        bbox = [0, 0, 100, 100]
        # Intersection is [75, 0, 100, 100], area = 25*100 = 2500
        # Span area is 50*100 = 5000
        # Overlap = 2500/5000 = 0.5
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.4); result_with_0_4 = codeflash_output # 8.91μs -> 4.16μs (114% faster)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result_with_0_5 = codeflash_output # 4.86μs -> 2.13μs (129% faster)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.6); result_with_0_6 = codeflash_output # 4.16μs -> 1.80μs (131% faster)

    def test_inverted_bbox_coordinates(self):
        """Test with inverted bbox coordinates (x_min > x_max)"""
        spans = [{"bbox": [10, 10, 50, 50], "text": "test"}]
        bbox = [100, 0, 0, 100]  # Inverted x coordinates
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.80μs -> 3.93μs (124% faster)

    def test_float_coordinates(self):
        """Test with floating-point bbox coordinates"""
        spans = [{"bbox": [10.5, 10.5, 49.5, 49.5], "text": "float"}]
        bbox = [0.0, 0.0, 100.0, 100.0]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 8.68μs -> 3.96μs (119% faster)

    def test_very_high_threshold(self):
        """Test with threshold > 1.0 (should exclude all spans)"""
        spans = [{"bbox": [10, 10, 50, 50], "text": "test"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=1.5); result = codeflash_output # 8.52μs -> 4.01μs (113% faster)

    def test_negative_threshold(self):
        """Test with negative threshold (should include all overlapping spans)"""
        spans = [{"bbox": [10, 10, 50, 50], "text": "test"}]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=-0.5); result = codeflash_output # 8.63μs -> 4.09μs (111% faster)

class TestGetBboxSpanSubsetLargeScale:
    """Large scale test cases for performance and scalability"""

    def test_many_non_overlapping_spans(self):
        """Test with many spans that don't overlap with bbox"""
        # Create 100 non-overlapping spans
        spans = [
            {"bbox": [i * 110, 0, i * 110 + 100, 100], "text": f"span_{i}"}
            for i in range(100)
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 297μs -> 66.2μs (349% faster)

    def test_many_overlapping_spans(self):
        """Test with many spans that all overlap with bbox"""
        # Create 100 overlapping spans all within bbox
        spans = [
            {"bbox": [i, i, 50 + i, 50 + i], "text": f"span_{i}"}
            for i in range(50)
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 161μs -> 43.8μs (268% faster)

    def test_mixed_overlapping_and_non_overlapping_large(self):
        """Test with large number of mixed overlapping/non-overlapping spans"""
        spans = []
        # Add 50 overlapping spans
        for i in range(50):
            spans.append({"bbox": [i, i, 50 + i, 50 + i], "text": f"overlap_{i}"})
        # Add 50 non-overlapping spans
        for i in range(50):
            spans.append(
                {"bbox": [200 + i * 10, 200 + i * 10, 210 + i * 10, 210 + i * 10], "text": f"no_overlap_{i}"}
            )
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 304μs -> 75.1μs (306% faster)

    def test_grid_of_spans(self):
        """Test with spans arranged in a grid pattern"""
        spans = []
        # Create a 10x10 grid of spans
        for i in range(10):
            for j in range(10):
                spans.append(
                    {
                        "bbox": [i * 20, j * 20, (i + 1) * 20, (j + 1) * 20],
                        "text": f"grid_{i}_{j}",
                    }
                )
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 307μs -> 74.8μs (311% faster)

    def test_spans_with_varying_threshold(self):
        """Test performance with varying threshold values on many spans"""
        spans = [
            {"bbox": [i * 2, 0, i * 2 + 100, 100], "text": f"span_{i}"}
            for i in range(50)
        ]
        bbox = [0, 0, 100, 100]
        
        # Test with different thresholds
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.0); result_0_0 = codeflash_output # 161μs -> 41.9μs (286% faster)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result_0_5 = codeflash_output # 154μs -> 38.7μs (299% faster)
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=1.0); result_1_0 = codeflash_output # 152μs -> 37.4μs (308% faster)

    def test_large_bbox_with_many_small_spans(self):
        """Test large bbox with many small spans inside"""
        spans = [
            {"bbox": [i, j, i + 1, j + 1], "text": f"small_{i}_{j}"}
            for i in range(50)
            for j in range(20)
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 3.11ms -> 769μs (304% faster)

    def test_small_bbox_with_many_large_spans(self):
        """Test small bbox with many large spans"""
        spans = [
            {"bbox": [i * 10 - 5, j * 10 - 5, i * 10 + 50, j * 10 + 50], "text": f"large_{i}_{j}"}
            for i in range(30)
            for j in range(30)
        ]
        bbox = [45, 45, 55, 55]  # Small bbox
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 2.66ms -> 600μs (342% faster)

    def test_spans_with_extreme_coordinates(self):
        """Test with spans having extreme coordinate values"""
        spans = [
            {"bbox": [0, 0, 1000000, 1000000], "text": "huge"},
            {"bbox": [1000000, 1000000, 2000000, 2000000], "text": "far"},
            {"bbox": [500000, 500000, 1500000, 1500000], "text": "overlap"},
        ]
        bbox = [0, 0, 1000000, 1000000]
        codeflash_output = get_bbox_span_subset(spans, bbox, threshold=0.5); result = codeflash_output # 18.5μs -> 7.62μs (143% faster)

    def test_default_threshold_parameter(self):
        """Test that default threshold=0.5 works correctly with many spans"""
        spans = [
            {"bbox": [i * 50, 0, i * 50 + 40, 100], "text": f"span_{i}"}
            for i in range(20)
        ]
        bbox = [0, 0, 100, 100]
        # Call without explicit threshold parameter
        codeflash_output = get_bbox_span_subset(spans, bbox); result = codeflash_output # 66.5μs -> 17.2μs (286% faster)

    def test_order_preservation(self):
        """Test that result preserves original span order"""
        spans = [
            {"bbox": [10, 10, 50, 50], "text": "first", "id": 1},
            {"bbox": [20, 20, 60, 60], "text": "second", "id": 2},
            {"bbox": [30, 30, 70, 70], "text": "third", "id": 3},
        ]
        bbox = [0, 0, 100, 100]
        codeflash_output = get_bbox_span_subset(spans, bbox); result = codeflash_output # 15.4μs -> 5.91μs (160% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-get_bbox_span_subset-mkospfud and push.