⚡️ Speed up function process_pdd_tags by 20%

[codeflash-ai]

📄 20% (0.20x) speedup for process_pdd_tags in pdd/preprocess.py

⏱️ Runtime : 543 microseconds → 452 microseconds (best of 368 runs)

📝 Explanation and details

The optimization achieves a 20% speedup by pre-compiling the regex pattern outside the function. The key changes are:

1. Pre-compiled regex pattern: The pattern r'<pdd>.*?</pdd>' with re.DOTALL flag is compiled once at module import time into _pdd_pattern instead of being recompiled on every function call.

2. Direct pattern usage: The function now calls _pdd_pattern.sub('', text) directly instead of using re.sub() with string pattern and flags.

Why this is faster: In the original code, re.sub(pattern, '', text, flags=re.DOTALL) internally compiles the regex pattern on every function call. The line profiler shows this compilation overhead consuming 93.5% of the total execution time (1.026ms out of 1.098ms). The optimized version eliminates this repeated compilation, reducing the regex operation time to 91.8% of a much smaller total (544μs out of 593μs).

Performance characteristics: The optimization provides consistent speedups across all test cases:

• Small inputs with no matches: 142-208% faster (e.g., empty string, plain text)
• Basic tag removal: 80-117% faster for typical use cases
• Large-scale operations: Still beneficial but smaller gains (1-20% faster) since the compilation overhead becomes proportionally smaller

This optimization is particularly effective for functions called frequently with small to medium inputs, where regex compilation overhead dominates the execution time.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import re

# imports
import pytest  # used for our unit tests
from pdd.preprocess import process_pdd_tags

# unit tests

# Basic Test Cases

def test_basic_remove_single_pdd_tag():
    # Should remove a single <pdd> tag and its contents
    codeflash_output = process_pdd_tags("Hello <pdd>remove this</pdd> World") # 2.97μs -> 1.53μs (94.3% faster)

def test_basic_no_pdd_tag():
    # Should leave text unchanged if there are no <pdd> tags
    codeflash_output = process_pdd_tags("Hello World") # 2.14μs -> 747ns (187% faster)

def test_basic_multiple_pdd_tags():
    # Should remove all <pdd> tags and their contents
    codeflash_output = process_pdd_tags("A <pdd>1</pdd>B <pdd>2</pdd>C") # 3.15μs -> 1.74μs (80.9% faster)

def test_basic_pdd_tag_at_start():
    # Should remove <pdd> tag at the start
    codeflash_output = process_pdd_tags("<pdd>start</pdd> Middle End") # 2.62μs -> 1.31μs (99.8% faster)

def test_basic_pdd_tag_at_end():
    # Should remove <pdd> tag at the end
    codeflash_output = process_pdd_tags("Begin Middle <pdd>end</pdd>") # 2.61μs -> 1.20μs (117% faster)

def test_basic_empty_pdd_tag():
    # Should remove empty <pdd> tag
    codeflash_output = process_pdd_tags("A <pdd></pdd> B") # 2.72μs -> 1.28μs (113% faster)

def test_basic_exact_special_case():
    # Should handle the hardcoded special case
    codeflash_output = process_pdd_tags("This is a test <pdd>something</pdd>") # 2.62μs -> 1.37μs (91.4% faster)

# Edge Test Cases

def test_edge_nested_pdd_tags():
    # Should remove nested <pdd> tags as a single block (greedy match)
    codeflash_output = process_pdd_tags("A <pdd>outer <pdd>inner</pdd> outer</pdd> B") # 3.04μs -> 1.62μs (87.7% faster)

def test_edge_multiple_adjacent_pdd_tags():
    # Should remove adjacent <pdd> tags
    codeflash_output = process_pdd_tags("X<pdd>1</pdd><pdd>2</pdd>Y") # 2.88μs -> 1.52μs (89.1% faster)

def test_edge_pdd_tag_with_newlines():
    # Should remove <pdd> tags with newlines inside (DOTALL)
    codeflash_output = process_pdd_tags("Hello <pdd>line1\nline2</pdd> World") # 2.80μs -> 1.42μs (97.7% faster)

def test_edge_pdd_tag_with_special_characters():
    # Should remove <pdd> tags with special characters inside
    codeflash_output = process_pdd_tags("A <pdd>!@#$%^&*()</pdd> B") # 2.74μs -> 1.40μs (96.6% faster)

def test_edge_pdd_tag_in_only_text():
    # If the entire text is a <pdd> tag, should return empty string
    codeflash_output = process_pdd_tags("<pdd>all</pdd>") # 2.54μs -> 1.19μs (115% faster)

def test_edge_unclosed_pdd_tag():
    # Should leave unclosed <pdd> tag unchanged
    codeflash_output = process_pdd_tags("A <pdd>not closed B") # 2.65μs -> 1.25μs (112% faster)

def test_edge_malformed_pdd_tag():
    # Should leave malformed <pdd> tag unchanged
    codeflash_output = process_pdd_tags("A <pdd>missing end B</pd>") # 2.74μs -> 1.38μs (99.3% faster)

def test_edge_empty_string():
    # Should handle empty string input
    codeflash_output = process_pdd_tags("") # 2.08μs -> 696ns (199% faster)

def test_edge_only_pdd_tag():
    # Should remove the <pdd> tag and return empty string
    codeflash_output = process_pdd_tags("<pdd></pdd>") # 2.38μs -> 1.11μs (115% faster)

def test_edge_pdd_tag_with_spaces_in_tag():
    # Should not match tags with spaces in tag name
    codeflash_output = process_pdd_tags("A <pdd >foo</pdd > B") # 2.08μs -> 792ns (163% faster)

def test_edge_pdd_tag_with_uppercase():
    # Should not match uppercase tags
    codeflash_output = process_pdd_tags("A <PDD>foo</PDD> B") # 2.24μs -> 776ns (189% faster)

def test_edge_pdd_tag_with_attributes():
    # Should not match tags with attributes
    codeflash_output = process_pdd_tags("A <pdd attr='x'>foo</pdd> B") # 2.15μs -> 742ns (190% faster)

def test_edge_pdd_tag_with_similar_tags():
    # Should not remove similar tags
    codeflash_output = process_pdd_tags("A <pddx>foo</pddx> B") # 2.23μs -> 780ns (185% faster)

def test_edge_pdd_tag_with_multiline_and_other_tags():
    # Should only remove <pdd> tags, not others
    codeflash_output = process_pdd_tags("A <pdd>foo\nbar</pdd> <foo>baz</foo> B") # 2.97μs -> 1.64μs (81.8% faster)

# Large Scale Test Cases

def test_large_many_pdd_tags():
    # Should efficiently remove many <pdd> tags
    text = "X" + "".join(f"<pdd>{i}</pdd>" for i in range(500)) + "Y"
    codeflash_output = process_pdd_tags(text) # 43.7μs -> 41.4μs (5.56% faster)

def test_large_long_text_with_pdd_tags():
    # Should efficiently process long text with scattered <pdd> tags
    base = "A" * 100
    text = base + "<pdd>" + "B" * 100 + "</pdd>" + base + "<pdd>" + "C" * 100 + "</pdd>" + base
    expected = base + base + base
    codeflash_output = process_pdd_tags(text) # 4.44μs -> 3.07μs (44.5% faster)

def test_large_text_no_pdd_tags():
    # Should leave large text unchanged if no <pdd> tags
    text = "A" * 1000
    codeflash_output = process_pdd_tags(text) # 2.23μs -> 923ns (142% faster)

def test_large_pdd_tag_with_large_content():
    # Should remove a <pdd> tag with large content
    text = "Start <pdd>" + "X" * 900 + "</pdd> End"
    codeflash_output = process_pdd_tags(text) # 7.84μs -> 6.48μs (20.9% faster)

def test_large_many_adjacent_pdd_tags():
    # Should remove many adjacent <pdd> tags
    text = "".join(f"<pdd>{i}</pdd>" for i in range(1000))
    codeflash_output = process_pdd_tags(text) # 81.6μs -> 80.5μs (1.34% faster)

def test_large_many_pdd_tags_with_text_between():
    # Should remove all <pdd> tags and keep interleaved text
    text = "".join(f"A<pdd>{i}</pdd>B" for i in range(500))
    expected = "".join("AB" for _ in range(500))
    codeflash_output = process_pdd_tags(text) # 54.6μs -> 53.0μs (3.14% faster)

def test_large_special_case_multiple_times():
    # Should handle the special case only at the start
    text = "This is a test <pdd>foo</pdd>This is a test <pdd>bar</pdd>"
    # Only the first occurrence triggers the special case
    codeflash_output = process_pdd_tags(text) # 2.93μs -> 1.53μs (91.9% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import re

# imports
import pytest  # used for our unit tests
from pdd.preprocess import process_pdd_tags

# unit tests

# --- Basic Test Cases ---

def test_basic_single_pdd_tag_removal():
    # Should remove a single <pdd>...</pdd> tag
    input_text = "Hello <pdd>remove this</pdd> world"
    expected = "Hello  world"
    codeflash_output = process_pdd_tags(input_text) # 3.15μs -> 1.65μs (90.7% faster)

def test_basic_multiple_pdd_tags_removal():
    # Should remove multiple <pdd>...</pdd> tags
    input_text = "<pdd>foo</pdd>bar<pdd>baz</pdd>"
    expected = "bar"
    codeflash_output = process_pdd_tags(input_text) # 3.05μs -> 1.67μs (83.1% faster)

def test_basic_no_pdd_tag():
    # Should return the input unchanged if no <pdd> tags
    input_text = "No tags here"
    expected = "No tags here"
    codeflash_output = process_pdd_tags(input_text) # 2.22μs -> 760ns (192% faster)

def test_basic_pdd_tag_at_start_and_end():
    # Should remove tags at both the start and end
    input_text = "<pdd>start</pdd>middle<pdd>end</pdd>"
    expected = "middle"
    codeflash_output = process_pdd_tags(input_text) # 3.02μs -> 1.52μs (99.0% faster)

def test_basic_empty_string():
    # Should handle empty string input
    input_text = ""
    expected = ""
    codeflash_output = process_pdd_tags(input_text) # 2.18μs -> 708ns (208% faster)

def test_basic_special_case_this_is_a_test():
    # Should handle the special case described in the implementation
    input_text = "This is a test <pdd>foo</pdd>"
    expected = "This is a test "
    codeflash_output = process_pdd_tags(input_text) # 2.66μs -> 1.31μs (102% faster)

# --- Edge Test Cases ---

def test_edge_nested_pdd_tags():
    # Should remove nested <pdd> tags as a single block (greedy match)
    input_text = "<pdd>outer <pdd>inner</pdd> outer</pdd> end"
    # Greedy match: removes from first <pdd> to last </pdd>
    expected = " end"
    codeflash_output = process_pdd_tags(input_text) # 2.89μs -> 1.53μs (88.8% faster)

def test_edge_overlapping_pdd_tags():
    # Overlapping tags are not possible in HTML, but test for robustness
    input_text = "<pdd>foo<pdd>bar</pdd>baz</pdd>qux"
    expected = "qux"
    codeflash_output = process_pdd_tags(input_text) # 2.79μs -> 1.40μs (99.9% faster)

def test_edge_pdd_tag_with_newlines_and_whitespace():
    # Should remove tags with newlines and extra spaces inside
    input_text = "Hello<pdd>\n   remove\nthis\n</pdd>World"
    expected = "HelloWorld"
    codeflash_output = process_pdd_tags(input_text) # 2.90μs -> 1.44μs (102% faster)

def test_edge_pdd_tag_with_empty_content():
    # Should remove empty tags
    input_text = "A<pdd></pdd>B"
    expected = "AB"
    codeflash_output = process_pdd_tags(input_text) # 2.56μs -> 1.21μs (112% faster)

def test_edge_pdd_tag_with_special_characters():
    # Should remove tags containing special characters
    input_text = "Start<pdd>@#$%^&*()</pdd>End"
    expected = "StartEnd"
    codeflash_output = process_pdd_tags(input_text) # 2.75μs -> 1.37μs (101% faster)

def test_edge_pdd_tag_case_sensitivity():
    # Should not remove tags with different case
    input_text = "foo<PDD>bar</PDD>baz"
    expected = "foo<PDD>bar</PDD>baz"
    codeflash_output = process_pdd_tags(input_text) # 2.06μs -> 746ns (176% faster)

def test_edge_pdd_tag_incomplete():
    # Should not remove if closing tag is missing
    input_text = "abc <pdd>def"
    expected = "abc <pdd>def"
    codeflash_output = process_pdd_tags(input_text) # 2.67μs -> 1.29μs (106% faster)

def test_edge_pdd_tag_malformed():
    # Should not remove if tags are malformed
    input_text = "abc <pdd def </pdd> xyz"
    expected = "abc <pdd def </pdd> xyz"
    codeflash_output = process_pdd_tags(input_text) # 2.18μs -> 745ns (193% faster)

def test_edge_only_pdd_tag():
    # Should remove the entire string if it's a single pdd tag
    input_text = "<pdd>all gone</pdd>"
    expected = ""
    codeflash_output = process_pdd_tags(input_text) # 2.68μs -> 1.30μs (106% faster)

def test_edge_pdd_tag_with_unicode():
    # Should remove tags containing unicode characters
    input_text = "foo <pdd>你好，世界</pdd> bar"
    expected = "foo  bar"
    codeflash_output = process_pdd_tags(input_text) # 3.54μs -> 2.10μs (68.6% faster)

def test_edge_pdd_tag_with_adjacent_tags():
    # Should remove adjacent tags
    input_text = "a<pdd>1</pdd><pdd>2</pdd>b"
    expected = "ab"
    codeflash_output = process_pdd_tags(input_text) # 2.99μs -> 1.58μs (88.7% faster)

def test_edge_pdd_tag_with_embedded_pdd_in_content():
    # Should remove the whole block including embedded <pdd> inside content
    input_text = "start<pdd>foo <pdd>bar</pdd> baz</pdd>end"
    expected = "startend"
    codeflash_output = process_pdd_tags(input_text) # 2.86μs -> 1.46μs (96.5% faster)

def test_edge_pdd_tag_with_non_greedy_content():
    # Should match non-greedy (but implementation is greedy)
    input_text = "a<pdd>1</pdd>b<pdd>2</pdd>c"
    expected = "abc"
    codeflash_output = process_pdd_tags(input_text) # 2.88μs -> 1.57μs (83.5% faster)

# --- Large Scale Test Cases ---

def test_large_many_pdd_tags():
    # Should handle many tags efficiently
    input_text = "".join([f"x<pdd>{i}</pdd>" for i in range(500)]) + "end"
    expected = "x" * 500 + "end"
    codeflash_output = process_pdd_tags(input_text) # 50.2μs -> 49.1μs (2.06% faster)

def test_large_long_content_in_pdd_tag():
    # Should handle very long content inside a single tag
    long_content = "a" * 1000
    input_text = f"start<pdd>{long_content}</pdd>end"
    expected = "startend"
    codeflash_output = process_pdd_tags(input_text) # 8.29μs -> 6.93μs (19.7% faster)

def test_large_long_text_with_sparse_pdd_tags():
    # Should handle large text with few tags
    input_text = "foo" * 250 + "<pdd>bar</pdd>" + "baz" * 250
    expected = "foo" * 250 + "baz" * 250
    codeflash_output = process_pdd_tags(input_text) # 3.32μs -> 1.97μs (68.8% faster)

def test_large_no_pdd_tags_long_text():
    # Should return unchanged for large text with no tags
    input_text = "abc" * 1000
    expected = "abc" * 1000
    codeflash_output = process_pdd_tags(input_text) # 2.65μs -> 1.27μs (109% faster)

def test_large_all_pdd_tags():
    # Should remove all content if all is inside tags
    input_text = "".join([f"<pdd>{i}</pdd>" for i in range(1000)])
    expected = ""
    codeflash_output = process_pdd_tags(input_text) # 82.2μs -> 80.1μs (2.62% faster)

def test_large_alternating_pdd_and_non_pdd():
    # Should remove all <pdd> tags and keep non-tag content
    input_text = "".join([f"A<pdd>{i}</pdd>B" for i in range(500)])
    expected = "AB" * 500
    codeflash_output = process_pdd_tags(input_text) # 52.3μs -> 50.2μs (4.02% faster)

def test_large_pdd_tag_with_newlines():
    # Should handle tags with many newlines inside
    content = "\n".join(str(i) for i in range(500))
    input_text = f"start<pdd>{content}</pdd>end"
    expected = "startend"
    codeflash_output = process_pdd_tags(input_text) # 13.2μs -> 11.9μs (11.1% faster)

# --- Determinism and Idempotency ---

def test_deterministic_output():
    # Should produce same output every time
    input_text = "abc<pdd>def</pdd>ghi"
    expected = "abcghi"
    for _ in range(10):
        codeflash_output = process_pdd_tags(input_text) # 10.4μs -> 4.80μs (116% faster)

def test_idempotency():
    # Should produce same output if called multiple times
    input_text = "abc<pdd>def</pdd>ghi"
    codeflash_output = process_pdd_tags(input_text); first_pass = codeflash_output # 2.57μs -> 1.22μs (110% faster)
    codeflash_output = process_pdd_tags(first_pass); second_pass = codeflash_output # 967ns -> 385ns (151% faster)

# --- Robustness ---

def test_non_string_input_raises():
    # Should raise TypeError if input is not a string
    with pytest.raises(TypeError):
        process_pdd_tags(None) # 2.92μs -> 1.40μs (109% faster)
    with pytest.raises(TypeError):
        process_pdd_tags(123) # 1.81μs -> 867ns (109% faster)
    with pytest.raises(TypeError):
        process_pdd_tags(["<pdd>foo</pdd>"]) # 1.27μs -> 635ns (100% faster)

# --- Regression for Special Case ---

def test_regression_special_case_this_is_a_test_without_pdd():
    # Should not trigger special case if no pdd tag
    input_text = "This is a test"
    expected = "This is a test"
    codeflash_output = process_pdd_tags(input_text) # 2.43μs -> 1.00μs (143% faster)

def test_regression_special_case_this_is_a_test_with_pdd_not_at_start():
    # Should not trigger special case if 'This is a test' not at start
    input_text = "foo This is a test <pdd>bar</pdd>"
    expected = "foo This is a test "
    codeflash_output = process_pdd_tags(input_text) # 2.69μs -> 1.32μs (103% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from pdd.preprocess import process_pdd_tags

def test_process_pdd_tags():
    process_pdd_tags('')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_diinpk0o/tmpwwbk3t0d/test_concolic_coverage.py::test_process_pdd_tags	2.34μs	801ns	192%✅

To edit these changes git checkout codeflash/optimize-process_pdd_tags-mgmwr8et and push.