⚡️ Speed up function format_title by 26%

[codeflash-ai]

📄 26% (0.26x) speedup for format_title in gradio/cli/commands/deploy_space.py

⏱️ Runtime : 936 microseconds → 741 microseconds (best of 114 runs)

📝 Explanation and details

The optimized code achieves a 26% speedup by pre-compiling regex patterns and replacing string operations with more efficient alternatives:

Key Optimizations:

1. Pre-compiled regex patterns: The two re.sub() calls now use pre-compiled patterns (_invalid_chars_pattern and _hyphens_pattern) instead of recompiling the regex on every function call. This eliminates the regex compilation overhead, which was consuming 46.6% and 14.2% of the original runtime respectively.

2. String method replacement: The while loop that stripped leading dots (consuming 35.7% of original runtime across 1,763 iterations) is replaced with a single title.lstrip(".") call, which is a native string operation optimized in C.

Performance Impact by Test Case:

• Large-scale tests with many leading periods: Show dramatic improvements (436-536% faster) because lstrip() handles all leading dots in one operation vs. the original character-by-character loop
• Basic character filtering: 40-90% faster due to pre-compiled regex patterns avoiding repeated compilation costs
• Unicode-heavy tests: Moderate improvements (2-35% faster) since regex compilation overhead is reduced
• Very large inputs: Smaller but consistent gains (2-15% faster) as the optimization overhead becomes proportionally less significant

The optimizations are most effective for inputs with many leading dots or frequent function calls, while maintaining identical functionality across all test cases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import re
import string  # used for generating large scale test cases

# imports
import pytest  # used for our unit tests
from gradio.cli.commands.deploy_space import format_title

# unit tests

# -------------------------
# Basic Test Cases
# -------------------------

def test_basic_alphanumeric():
    # Should preserve alphanumeric characters and underscores for spaces
    codeflash_output = format_title("Hello World") # 3.82μs -> 2.54μs (50.5% faster)
    codeflash_output = format_title("Python3") # 1.56μs -> 838ns (86.3% faster)
    codeflash_output = format_title("My-Title") # 1.90μs -> 1.30μs (46.0% faster)
    codeflash_output = format_title("My.Title") # 1.09μs -> 565ns (93.5% faster)
    codeflash_output = format_title("My_Title") # 1.06μs -> 521ns (104% faster)

def test_basic_mixed_characters():
    # Should remove special characters except - . _
    codeflash_output = format_title("Hello@World!") # 4.24μs -> 2.98μs (42.1% faster)
    codeflash_output = format_title("A+B=C") # 2.01μs -> 1.30μs (54.3% faster)
    codeflash_output = format_title("Title#1") # 1.42μs -> 905ns (56.8% faster)
    codeflash_output = format_title("Good$Morning") # 1.43μs -> 942ns (51.9% faster)

def test_basic_multiple_spaces():
    # Multiple spaces become multiple underscores
    codeflash_output = format_title("Hello   World") # 3.37μs -> 2.43μs (38.8% faster)
    codeflash_output = format_title("  Leading and trailing  ") # 1.79μs -> 1.17μs (53.5% faster)

def test_basic_multiple_hyphens():
    # Multiple consecutive hyphens become a single hyphen
    codeflash_output = format_title("Hello--World") # 4.19μs -> 2.83μs (48.3% faster)
    codeflash_output = format_title("A---B") # 1.75μs -> 1.09μs (60.4% faster)
    codeflash_output = format_title("A--B--C") # 1.47μs -> 957ns (53.4% faster)

def test_basic_dot_handling():
    # Leading dots should be removed, but internal dots preserved
    codeflash_output = format_title("..Hello.World") # 3.94μs -> 2.16μs (82.1% faster)
    codeflash_output = format_title(".Title") # 1.61μs -> 870ns (85.6% faster)
    codeflash_output = format_title("...Multiple.Dots") # 1.67μs -> 866ns (93.2% faster)
    codeflash_output = format_title("A.B.C") # 1.09μs -> 570ns (91.9% faster)

# -------------------------
# Edge Test Cases
# -------------------------

def test_edge_empty_string():
    # Empty string should return empty string
    codeflash_output = format_title("") # 2.61μs -> 1.43μs (82.4% faster)

def test_edge_only_spaces():
    # Only spaces should become only underscores
    codeflash_output = format_title("   ") # 3.76μs -> 2.42μs (55.1% faster)

def test_edge_only_special_characters():
    # Only special characters (not allowed) should be removed
    codeflash_output = format_title("@#$%^&*()") # 4.68μs -> 3.18μs (47.4% faster)

def test_edge_only_hyphens():
    # Only hyphens should be collapsed to a single hyphen
    codeflash_output = format_title("----") # 3.50μs -> 2.32μs (50.6% faster)

def test_edge_only_dots():
    # Only dots should be removed (all are leading)
    codeflash_output = format_title("....") # 4.21μs -> 2.39μs (76.6% faster)

def test_edge_mixed_leading_specials():
    # Leading special characters (dots, spaces, hyphens) should be handled
    codeflash_output = format_title("..--Hello") # 4.64μs -> 3.09μs (50.4% faster)
    codeflash_output = format_title(".. Hello") # 1.91μs -> 1.02μs (87.6% faster)
    codeflash_output = format_title("..-- Hello") # 1.77μs -> 1.05μs (67.6% faster)

def test_edge_trailing_special_characters():
    # Trailing special characters should be removed if not allowed
    codeflash_output = format_title("Hello!!!") # 4.19μs -> 2.94μs (42.2% faster)
    codeflash_output = format_title("Title...") # 1.50μs -> 856ns (75.0% faster)
    codeflash_output = format_title("Title---") # 1.40μs -> 877ns (59.6% faster)
    codeflash_output = format_title("Title___") # 1.03μs -> 511ns (102% faster)

def test_edge_unicode_characters():
    # Unicode characters should be removed
    codeflash_output = format_title("Café") # 4.17μs -> 2.66μs (56.8% faster)
    codeflash_output = format_title("你好世界") # 2.57μs -> 2.00μs (28.7% faster)
    codeflash_output = format_title("Grüße") # 1.81μs -> 1.27μs (42.6% faster)
    codeflash_output = format_title("Résumé") # 1.55μs -> 1.00μs (54.7% faster)

def test_edge_mixed_case():
    # Should preserve case for allowed characters
    codeflash_output = format_title("MiXeD CaSe") # 3.61μs -> 2.35μs (53.6% faster)
    codeflash_output = format_title("tEsT-Title") # 2.09μs -> 1.45μs (44.7% faster)

def test_edge_long_leading_dots_and_specials():
    # Long string of leading dots and specials
    codeflash_output = format_title("....---___Hello") # 4.75μs -> 2.97μs (60.0% faster)

# -------------------------
# Large Scale Test Cases
# -------------------------

def test_large_scale_long_string():
    # Test with a very long string of allowed and disallowed characters
    long_title = "A" * 500 + " " + "!" * 200 + "B" * 300
    expected = "A" * 500 + "_" + "B" * 300
    codeflash_output = format_title(long_title) # 23.8μs -> 21.8μs (9.09% faster)

def test_large_scale_many_spaces_and_hyphens():
    # Test with alternating spaces and hyphens, should collapse hyphens and convert spaces
    title = (" " * 10 + "-" * 10) * 50  # 1000 characters
    # Spaces become underscores, hyphens become single hyphen
    # Each block becomes: "__________-" (10 underscores, 1 hyphen)
    expected = ("_" * 10 + "-") * 50
    codeflash_output = format_title(title) # 16.3μs -> 14.8μs (10.4% faster)

def test_large_scale_all_special_characters():
    # Large string of only special characters should be removed
    specials = "".join([chr(i) for i in range(33, 48)]) * 50  # 750 characters
    codeflash_output = format_title(specials) # 44.8μs -> 43.8μs (2.42% faster)

def test_large_scale_mixed_alphanum_and_special():
    # Large string with alternating allowed and disallowed characters
    allowed = string.ascii_letters + string.digits + "-._"
    disallowed = "@#$%^&*()+=[]{}|;:'\",<>/?`~"
    title = (allowed + disallowed) * 10  # length < 1000
    expected = allowed * 10
    codeflash_output = format_title(title) # 27.5μs -> 25.8μs (6.56% faster)

def test_large_scale_leading_dots():
    # Large number of leading dots, should all be removed
    title = "." * 100 + "HelloWorld"
    codeflash_output = format_title(title) # 11.2μs -> 3.75μs (198% faster)

def test_large_scale_spaces_and_dots():
    # Large number of spaces and dots, spaces turn to underscores, leading dots removed
    title = "." * 50 + " " * 50 + "Test"
    # 50 dots removed, 50 spaces become underscores
    expected = "_" * 50 + "Test"
    codeflash_output = format_title(title) # 8.05μs -> 3.58μs (125% faster)

def test_large_scale_randomized():
    # Randomized string with many allowed/disallowed characters
    import random
    allowed = string.ascii_letters + string.digits + "-._"
    disallowed = "@#$%^&*()+=[]{}|;:'\",<>/?`~"
    title = "".join(random.choices(allowed + disallowed + " ", k=999))
    # The output should only contain allowed characters and underscores for spaces, no leading dots
    codeflash_output = format_title(title); result = codeflash_output # 40.3μs -> 38.8μs (4.10% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

import re
import string  # used for generating large scale test cases

# imports
import pytest  # used for our unit tests
from gradio.cli.commands.deploy_space import format_title

# unit tests

# -------- BASIC TEST CASES --------

def test_basic_alphanumeric():
    # Basic alphanumeric input should be unchanged except spaces to underscores
    codeflash_output = format_title("Hello World") # 4.03μs -> 2.55μs (58.0% faster)
    codeflash_output = format_title("Python3") # 1.44μs -> 756ns (90.2% faster)
    codeflash_output = format_title("Title_123") # 1.15μs -> 636ns (80.2% faster)

def test_basic_hyphens_and_periods():
    # Hyphens and periods should be preserved, multiple hyphens collapsed
    codeflash_output = format_title("My--Title") # 4.01μs -> 2.82μs (42.3% faster)
    codeflash_output = format_title("File.name.txt") # 1.51μs -> 897ns (68.3% faster)
    codeflash_output = format_title("A - B - C") # 1.85μs -> 1.29μs (43.3% faster)

def test_basic_special_characters():
    # Special characters should be removed
    codeflash_output = format_title("Hello@World!") # 4.17μs -> 2.97μs (40.6% faster)
    codeflash_output = format_title("Good#Morning$") # 1.80μs -> 1.24μs (46.0% faster)
    codeflash_output = format_title("A&B*C") # 1.57μs -> 1.06μs (48.2% faster)

def test_basic_spaces_and_underscores():
    # Spaces become underscores, underscores preserved
    codeflash_output = format_title("A B_C D") # 3.57μs -> 2.29μs (56.0% faster)
    codeflash_output = format_title("   Leading and trailing   ") # 1.85μs -> 1.20μs (53.8% faster)

# -------- EDGE TEST CASES --------

def test_empty_string():
    # Empty string should return empty string
    codeflash_output = format_title("") # 2.62μs -> 1.44μs (81.6% faster)

def test_only_special_characters():
    # Only special characters should result in empty string
    codeflash_output = format_title("@#$%^&*()") # 4.47μs -> 3.23μs (38.4% faster)

def test_only_spaces():
    # Only spaces should become underscores
    codeflash_output = format_title("     ") # 3.52μs -> 2.46μs (43.1% faster)

def test_only_periods():
    # Leading periods should be stripped
    codeflash_output = format_title("...abc") # 4.13μs -> 2.35μs (75.7% faster)
    codeflash_output = format_title("....") # 1.98μs -> 911ns (117% faster)
    codeflash_output = format_title(".a.b.c.") # 1.29μs -> 719ns (80.0% faster)

def test_leading_and_trailing_periods():
    # Leading periods stripped, trailing preserved
    codeflash_output = format_title("..A..B..C..") # 3.85μs -> 2.30μs (67.2% faster)
    codeflash_output = format_title(".Title.") # 1.60μs -> 872ns (83.0% faster)

def test_multiple_hyphens():
    # Multiple consecutive hyphens collapsed to one
    codeflash_output = format_title("A---B--C----D") # 4.24μs -> 3.11μs (36.6% faster)
    codeflash_output = format_title("--A--B--") # 1.92μs -> 1.25μs (53.5% faster)

def test_unicode_characters():
    # Unicode characters (non-ASCII) should be removed
    codeflash_output = format_title("Café Münster") # 4.91μs -> 3.64μs (34.6% faster)
    codeflash_output = format_title("你好世界") # 2.57μs -> 1.96μs (31.3% faster)
    codeflash_output = format_title("Résumé") # 1.84μs -> 1.30μs (41.9% faster)

def test_mixed_case():
    # Case should be preserved
    codeflash_output = format_title("tEsT TiTlE") # 3.48μs -> 2.35μs (48.2% faster)

def test_leading_trailing_spaces_and_specials():
    # Leading/trailing spaces and specials handled properly
    codeflash_output = format_title("   @Title!   ") # 4.67μs -> 3.50μs (33.4% faster)
    codeflash_output = format_title(" .@!abc@! ") # 2.39μs -> 1.83μs (30.4% faster)

def test_only_underscores():
    # Underscores should be preserved
    codeflash_output = format_title("___") # 3.46μs -> 2.16μs (60.6% faster)

def test_dash_and_period_edge():
    # Dashes and periods at start and end
    codeflash_output = format_title("-.-abc-.--") # 4.60μs -> 3.31μs (39.1% faster)

# -------- LARGE SCALE TEST CASES --------

def test_large_input_alphanumeric():
    # Large input of alphanumeric characters
    long_str = "A" * 1000 + " " + "B" * 1000
    expected = "A" * 1000 + "_" + "B" * 1000
    codeflash_output = format_title(long_str) # 20.1μs -> 19.1μs (4.93% faster)

def test_large_input_with_specials():
    # Large input with many special characters
    specials = "@#$%^&*()" * 100
    base = "Title"
    long_str = specials + base + specials
    codeflash_output = format_title(long_str) # 93.6μs -> 93.3μs (0.259% faster)

def test_large_input_mixed():
    # Large input with mix of valid and invalid characters
    valid = string.ascii_letters + string.digits + "-._"
    invalid = "@#$%^&*()" * 50
    mixed = (valid + invalid) * 10
    # Remove invalid characters, collapse hyphens, strip leading periods
    expected = re.sub(r"[^a-zA-Z0-9\-._]", "", mixed)
    expected = re.sub("-+", "-", expected)
    while expected.startswith("."):
        expected = expected[1:]
    codeflash_output = format_title(mixed) # 228μs -> 232μs (1.99% slower)

def test_large_input_only_periods():
    # Large input of only periods
    periods = "." * 1000
    codeflash_output = format_title(periods) # 89.0μs -> 14.0μs (536% faster)

def test_large_input_only_spaces():
    # Large input of only spaces
    spaces = " " * 1000
    codeflash_output = format_title(spaces) # 13.1μs -> 11.5μs (14.1% faster)

def test_large_input_only_hyphens():
    # Large input of only hyphens (should collapse to one hyphen)
    hyphens = "-" * 1000
    codeflash_output = format_title(hyphens) # 6.92μs -> 5.46μs (26.9% faster)

def test_large_input_leading_periods():
    # Large input with leading periods and valid content
    s = "." * 500 + "abc"
    codeflash_output = format_title(s) # 43.7μs -> 8.14μs (436% faster)

def test_large_input_unicode():
    # Large input of unicode characters (should be removed)
    unicode_str = "你好世界" * 250
    codeflash_output = format_title(unicode_str) # 57.3μs -> 56.1μs (2.10% faster)

def test_large_input_mixed_unicode_and_ascii():
    # Large input with mixed unicode and ascii
    ascii_part = "Title123"
    unicode_part = "你好世界" * 125
    mixed = ascii_part + unicode_part + ascii_part
    codeflash_output = format_title(mixed) # 32.6μs -> 31.5μs (3.55% 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-format_title-mhb0piaf and push.