⚡️ Speed up function is_inline_element by 303%

[codeflash-ai]

📄 303% (3.03x) speedup for is_inline_element in unstructured/partition/html/transformations.py

⏱️ Runtime : 999 microseconds → 248 microseconds (best of 120 runs)

📝 Explanation and details

The optimization achieves a 302% speedup by moving constant list/tuple creation out of the function and using more efficient Python operations.

Key optimizations applied:

1. Moved constants to module level: The inline_classes and inline_categories collections are now defined once at module load time as tuples, eliminating the overhead of recreating these collections on every function call. The line profiler shows this eliminated ~1.1ms of overhead (31.9% + 39.7% of original runtime).

2. Replaced any() with direct isinstance(): Instead of using a generator expression with any() to check class membership, the code now uses isinstance(ontology_element, inline_classes) directly with a tuple of classes. This is more efficient because isinstance() can natively handle tuple arguments.

3. Replaced any() with in operator: The second check now uses ontology_element.elementType in inline_categories instead of a generator expression with any(). The in operator on tuples is optimized at the C level and significantly faster than generator-based iteration.

4. Used tuples instead of lists: Tuples are slightly more memory-efficient and faster for membership testing than lists, especially for small collections.

Performance impact in context:
Based on the function reference, is_inline_element() is called within a loop in can_unstructured_elements_be_merged() when processing HTML elements. Since HTML parsing often involves checking many elements, this optimization provides substantial benefits in document processing pipelines where this function may be called hundreds or thousands of times.

Test case insights:
The optimization shows consistent 150-340% speedups across all test scenarios, with particularly strong performance on large-scale tests (295-338% faster) where the constant overhead elimination compounds. Both basic element type checking and class inheritance checking benefit significantly, making this optimization valuable for diverse HTML parsing workloads.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from unstructured.partition.html.transformations import is_inline_element

# --- Minimal stubs for dependencies (since we can't import the actual ontology module) ---


class ElementTypeEnum:
    specialized_text = "specialized_text"
    annotation = "annotation"
    narrative_text = "narrative_text"
    title = "title"
    header = "header"
    # Add more as needed for edge/large tests


class OntologyElement:
    def __init__(self, elementType=None):
        self.elementType = elementType


class Hyperlink(OntologyElement):
    pass


# Simulate the ontology module namespace
class ontology:
    OntologyElement = OntologyElement
    Hyperlink = Hyperlink
    ElementTypeEnum = ElementTypeEnum


# ---------------------- UNIT TESTS ----------------------

# 1. Basic Test Cases


def test_hyperlink_is_inline():
    """Hyperlink instance should always return True."""
    el = ontology.Hyperlink()
    codeflash_output = is_inline_element(el)  # 1.71μs -> 625ns (173% faster)


def test_specialized_text_is_inline():
    """Element with elementType specialized_text should return True."""
    el = ontology.OntologyElement(elementType=ontology.ElementTypeEnum.specialized_text)
    codeflash_output = is_inline_element(el)  # 1.54μs -> 500ns (208% faster)


def test_annotation_is_inline():
    """Element with elementType annotation should return True."""
    el = ontology.OntologyElement(elementType=ontology.ElementTypeEnum.annotation)
    codeflash_output = is_inline_element(el)  # 1.42μs -> 500ns (183% faster)


def test_narrative_text_is_not_inline():
    """Element with unrelated elementType should return False."""
    el = ontology.OntologyElement(elementType=ontology.ElementTypeEnum.narrative_text)
    codeflash_output = is_inline_element(el)  # 1.33μs -> 375ns (255% faster)


def test_title_is_not_inline():
    """Element with another unrelated elementType should return False."""
    el = ontology.OntologyElement(elementType=ontology.ElementTypeEnum.title)
    codeflash_output = is_inline_element(el)  # 1.25μs -> 375ns (233% faster)


# 2. Edge Test Cases


def test_none_element_type():
    """Element with elementType=None should return False."""
    el = ontology.OntologyElement(elementType=None)
    codeflash_output = is_inline_element(el)  # 1.33μs -> 375ns (255% faster)


def test_hyperlink_with_inline_category():
    """Hyperlink with inline category should still return True (class check takes precedence)."""
    el = ontology.Hyperlink(elementType=ontology.ElementTypeEnum.specialized_text)
    codeflash_output = is_inline_element(el)  # 1.92μs -> 708ns (171% faster)


def test_hyperlink_with_noninline_category():
    """Hyperlink with non-inline category should still return True."""
    el = ontology.Hyperlink(elementType=ontology.ElementTypeEnum.narrative_text)
    codeflash_output = is_inline_element(el)  # 1.54μs -> 458ns (237% faster)


def test_subclass_of_hyperlink_is_inline():
    """A subclass of Hyperlink should be recognized as inline."""

    class CustomHyperlink(ontology.Hyperlink):
        pass

    el = CustomHyperlink()
    codeflash_output = is_inline_element(el)  # 1.62μs -> 625ns (160% faster)


def test_element_with_unknown_category():
    """Element with a category not in ElementTypeEnum should return False."""
    el = ontology.OntologyElement(elementType="unknown_category")
    codeflash_output = is_inline_element(el)  # 1.42μs -> 417ns (240% faster)


def test_element_with_empty_string_category():
    """Element with empty string as category should return False."""
    el = ontology.OntologyElement(elementType="")
    codeflash_output = is_inline_element(el)  # 1.33μs -> 416ns (220% faster)


def test_element_with_integer_category():
    """Element with integer category should return False."""
    el = ontology.OntologyElement(elementType=123)
    codeflash_output = is_inline_element(el)  # 1.38μs -> 458ns (200% faster)


def test_element_with_similar_but_not_equal_category():
    """Element with a category similar to but not equal to inline categories should return False."""
    el = ontology.OntologyElement(elementType="specialized_texts")  # note the 's'
    codeflash_output = is_inline_element(el)  # 1.29μs -> 375ns (244% faster)


def test_element_with_category_case_sensitivity():
    """Element with correct category but wrong case should return False."""
    el = ontology.OntologyElement(elementType="Specialized_Text")
    codeflash_output = is_inline_element(el)  # 1.33μs -> 416ns (220% faster)


def test_element_with_category_as_object():
    """Element with a non-string category should return False."""

    class Dummy:
        pass

    el = ontology.OntologyElement(elementType=Dummy())
    codeflash_output = is_inline_element(el)  # 1.38μs -> 416ns (231% faster)


# 3. Large Scale Test Cases


def test_many_non_inline_elements():
    """Test performance with a large number of non-inline elements."""
    elements = [
        ontology.OntologyElement(elementType=ontology.ElementTypeEnum.header) for _ in range(500)
    ]
    # All should be False
    for el in elements:
        codeflash_output = is_inline_element(el)  # 315μs -> 71.9μs (338% faster)


def test_many_inline_elements():
    """Test performance with a large number of inline elements (specialized_text)."""
    elements = [
        ontology.OntologyElement(elementType=ontology.ElementTypeEnum.specialized_text)
        for _ in range(500)
    ]
    for el in elements:
        codeflash_output = is_inline_element(el)  # 316μs -> 80.2μs (295% faster)


def test_large_number_of_hyperlinks():
    """Test a large number of Hyperlink instances."""
    elements = [ontology.Hyperlink() for _ in range(500)]
    for el in elements:
        codeflash_output = is_inline_element(el)  # 317μs -> 79.8μs (298% faster)

import pytest

from unstructured.partition.html.transformations import is_inline_element

# --- MOCKED ONTOLOGY CLASSES FOR TESTING PURPOSES ---
# These are minimal stand-ins to simulate the real ontology module.
# They allow us to test is_inline_element in isolation.


class MockElementTypeEnum:
    specialized_text = "specialized_text"
    annotation = "annotation"
    other = "other"
    # Add more if needed for edge cases


class MockOntologyElement:
    def __init__(self, elementType=None):
        self.elementType = elementType


class Hyperlink(MockOntologyElement):
    pass


# Patch for the ontology module as used in the function under test.
class ontology:
    Hyperlink = Hyperlink
    ElementTypeEnum = MockElementTypeEnum


# ------------------ UNIT TESTS ------------------

# 1. BASIC TEST CASES


def test_hyperlink_instance_returns_true():
    # Should return True for instance of Hyperlink
    element = ontology.Hyperlink()
    codeflash_output = is_inline_element(element)  # 1.83μs -> 583ns (214% faster)


def test_specialized_text_category_returns_true():
    # Should return True for elementType == specialized_text
    element = MockOntologyElement(elementType=ontology.ElementTypeEnum.specialized_text)
    codeflash_output = is_inline_element(element)  # 1.58μs -> 459ns (245% faster)


def test_annotation_category_returns_true():
    # Should return True for elementType == annotation
    element = MockOntologyElement(elementType=ontology.ElementTypeEnum.annotation)
    codeflash_output = is_inline_element(element)  # 1.46μs -> 459ns (218% faster)


def test_other_category_returns_false():
    # Should return False for elementType not in inline_categories
    element = MockOntologyElement(elementType=ontology.ElementTypeEnum.other)
    codeflash_output = is_inline_element(element)  # 1.33μs -> 375ns (255% faster)


def test_non_hyperlink_class_returns_false():
    # Should return False for unrelated class not in inline_classes
    class NotHyperlink(MockOntologyElement):
        pass

    element = NotHyperlink()
    codeflash_output = is_inline_element(element)  # 1.54μs -> 541ns (185% faster)


# 2. EDGE TEST CASES


def test_elementType_is_none():
    # Should return False if elementType is None
    element = MockOntologyElement(elementType=None)
    codeflash_output = is_inline_element(element)  # 2.00μs -> 666ns (200% faster)


def test_elementType_is_empty_string():
    # Should return False if elementType is empty string
    element = MockOntologyElement(elementType="")
    codeflash_output = is_inline_element(element)  # 1.62μs -> 500ns (225% faster)


def test_elementType_is_similar_but_not_exact():
    # Should return False for similar but not exact string
    element = MockOntologyElement(elementType="specializedtext")  # missing underscore
    codeflash_output = is_inline_element(element)  # 1.46μs -> 416ns (250% faster)


def test_hyperlink_subclass_returns_true():
    # Should return True for subclass of Hyperlink
    class CustomHyperlink(ontology.Hyperlink):
        pass

    element = CustomHyperlink()
    codeflash_output = is_inline_element(element)  # 1.54μs -> 583ns (164% faster)


def test_hyperlink_with_elementType_other():
    # Should return True for Hyperlink even if elementType is not in inline_categories
    element = ontology.Hyperlink(elementType=ontology.ElementTypeEnum.other)
    codeflash_output = is_inline_element(element)  # 1.42μs -> 375ns (278% faster)


def test_elementType_is_integer():
    # Should return False if elementType is an int, not a string
    element = MockOntologyElement(elementType=123)
    codeflash_output = is_inline_element(element)  # 1.29μs -> 458ns (182% faster)


def test_element_is_none():
    # Should raise AttributeError (or return False) if input is None
    with pytest.raises(AttributeError):
        is_inline_element(None)  # 1.83μs -> 833ns (120% faster)


# 3. LARGE SCALE TEST CASES


def test_elementType_is_object():
    # Should return False if elementType is an object, not a string
    element = MockOntologyElement(elementType=object())
    codeflash_output = is_inline_element(element)  # 2.00μs -> 708ns (182% faster)


def test_elementType_is_list():
    # Should return False if elementType is a list
    element = MockOntologyElement(elementType=["specialized_text"])
    codeflash_output = is_inline_element(element)  # 1.58μs -> 458ns (246% faster)


def test_elementType_is_bytes():
    # Should return False if elementType is bytes
    element = MockOntologyElement(elementType=b"specialized_text")
    codeflash_output = is_inline_element(element)  # 1.50μs -> 417ns (260% faster)


def test_hyperlink_with_elementType_none():
    # Should return True for Hyperlink even if elementType is None
    element = ontology.Hyperlink(elementType=None)
    codeflash_output = is_inline_element(element)  # 1.38μs -> 416ns (231% faster)


def test_hyperlink_with_elementType_specialized_text():
    # Should return True for Hyperlink even if elementType is in inline_categories
    element = ontology.Hyperlink(elementType=ontology.ElementTypeEnum.specialized_text)
    codeflash_output = is_inline_element(element)  # 1.38μs -> 417ns (230% faster)


# 5. NEGATIVE TESTS


def test_elementType_case_sensitivity():
    # Should return False if elementType is correct but wrong case
    element = MockOntologyElement(elementType="Specialized_Text")
    codeflash_output = is_inline_element(element)  # 2.04μs -> 708ns (188% 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-is_inline_element-mjccmo8h and push.