⚡️ Speed up function camel_to_kebab by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for camel_to_kebab in panel/util/__init__.py

⏱️ Runtime : 12.3 milliseconds → 11.1 milliseconds (best of 110 runs)

📝 Explanation and details

The optimization replaces repeated re.sub() calls with pre-compiled regex patterns stored as module-level constants. Instead of compiling the same regular expressions r'([a-z0-9])([A-Z])' and r'([A-Z]+)([A-Z][a-z0-9])' on every function call, the patterns are compiled once at module import time and reused.

Key changes:

• Added _pattern1 = re.compile(r'([a-z0-9])([A-Z])') and _pattern2 = re.compile(r'([A-Z]+)([A-Z][a-z0-9])') at module level
• Replaced re.sub() calls with _pattern1.sub() and _pattern2.sub() using the pre-compiled patterns

Why this is faster:
Regular expression compilation is expensive in Python. The original code recompiles both patterns every time camel_to_kebab() is called, while the optimized version compiles them once and reuses the compiled pattern objects. Pre-compiled patterns have faster .sub() methods since they skip the compilation step entirely.

Performance characteristics:
The line profiler shows the first regex operation improved from 13,719ns to 12,421ns per hit (9.5% faster) and the second from 4,267ns to 3,127ns per hit (26.7% faster). The optimization provides consistent 10-27% speedups across all test cases, with particularly strong gains on simple inputs like single words and basic camel case conversions. For large-scale operations with many function calls, the cumulative savings from avoiding repeated regex compilation becomes substantial, as seen in the batch processing test showing 23% improvement.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 2091 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

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import camel_to_kebab

# unit tests

# 1. BASIC TEST CASES

def test_basic_single_word():
    # Single word, no camel case
    codeflash_output = camel_to_kebab("hello") # 7.63μs -> 6.48μs (17.7% faster)
    codeflash_output = camel_to_kebab("world") # 2.88μs -> 2.29μs (26.0% faster)

def test_basic_simple_camel():
    # Basic camelCase
    codeflash_output = camel_to_kebab("camelCase") # 10.6μs -> 9.30μs (13.9% faster)
    codeflash_output = camel_to_kebab("simpleTest") # 4.13μs -> 3.66μs (12.8% faster)

def test_basic_multiple_camel():
    # Multiple camel transitions
    codeflash_output = camel_to_kebab("thisIsATest") # 11.5μs -> 10.2μs (13.6% faster)
    codeflash_output = camel_to_kebab("myXMLParser") # 5.30μs -> 4.48μs (18.5% faster)

def test_basic_starting_uppercase():
    # PascalCase input
    codeflash_output = camel_to_kebab("CamelCase") # 9.26μs -> 7.99μs (15.9% faster)
    codeflash_output = camel_to_kebab("SimpleTest") # 3.88μs -> 3.19μs (21.4% faster)

def test_basic_acronyms():
    # Acronyms in camel case
    codeflash_output = camel_to_kebab("parseHTMLFile") # 10.5μs -> 9.24μs (14.0% faster)
    codeflash_output = camel_to_kebab("getHTTPResponse") # 5.13μs -> 4.63μs (11.0% faster)
    codeflash_output = camel_to_kebab("getURLInfo") # 4.23μs -> 3.74μs (13.3% faster)

# 2. EDGE TEST CASES

def test_edge_empty_string():
    # Empty string input
    codeflash_output = camel_to_kebab("") # 5.64μs -> 4.19μs (34.5% faster)

def test_edge_single_character():
    # Single character input
    codeflash_output = camel_to_kebab("a") # 5.43μs -> 4.38μs (23.9% faster)
    codeflash_output = camel_to_kebab("Z") # 2.22μs -> 1.62μs (36.6% faster)

def test_edge_all_uppercase():
    # All uppercase input
    codeflash_output = camel_to_kebab("HTML") # 6.88μs -> 5.55μs (24.0% faster)
    codeflash_output = camel_to_kebab("API") # 2.75μs -> 2.28μs (20.6% faster)

def test_edge_all_lowercase():
    # All lowercase input
    codeflash_output = camel_to_kebab("html") # 6.60μs -> 5.18μs (27.4% faster)
    codeflash_output = camel_to_kebab("api") # 2.77μs -> 2.18μs (27.5% faster)

def test_edge_numbers_in_string():
    # Numbers in the string
    codeflash_output = camel_to_kebab("version2Update") # 10.3μs -> 9.26μs (11.2% faster)
    codeflash_output = camel_to_kebab("getHTTP2Response") # 7.03μs -> 6.16μs (14.2% faster)
    codeflash_output = camel_to_kebab("parseXML123File") # 5.49μs -> 4.98μs (10.2% faster)

def test_edge_leading_trailing_uppercase():
    # Leading/trailing uppercase letters
    codeflash_output = camel_to_kebab("XMLHttpRequest") # 10.3μs -> 9.49μs (8.93% faster)
    codeflash_output = camel_to_kebab("HTTPRequestXML") # 5.21μs -> 4.58μs (13.8% faster)

def test_edge_consecutive_uppercase_groups():
    # Consecutive uppercase letters (acronym followed by camel)
    codeflash_output = camel_to_kebab("getHTTPXMLResponse") # 10.4μs -> 8.98μs (15.3% faster)
    codeflash_output = camel_to_kebab("parseJSONAPIData") # 4.94μs -> 4.30μs (14.8% faster)

def test_edge_underscore_and_hyphen():
    # Underscores and hyphens should not be changed
    codeflash_output = camel_to_kebab("camel_Case") # 6.76μs -> 5.68μs (19.1% faster)
    codeflash_output = camel_to_kebab("camel-Case") # 3.08μs -> 2.56μs (20.3% faster)

def test_edge_non_ascii_characters():
    # Non-ASCII characters (should be preserved, not split)
    codeflash_output = camel_to_kebab("naïveTest") # 10.4μs -> 9.16μs (13.1% faster)
    codeflash_output = camel_to_kebab("überCoolStuff") # 5.80μs -> 4.87μs (19.1% faster)

def test_edge_digits_and_uppercase():
    # Digits adjacent to uppercase
    codeflash_output = camel_to_kebab("abc123DEF456GHI") # 11.8μs -> 11.0μs (7.13% faster)

def test_edge_mixed_case():
    # Mixed case, not strictly camel or pascal
    codeflash_output = camel_to_kebab("aBcDeF") # 10.5μs -> 9.20μs (13.8% faster)
    codeflash_output = camel_to_kebab("TestABCdEf") # 6.34μs -> 5.47μs (16.0% faster)

def test_edge_only_uppercase_and_digits():
    # Only uppercase and digits
    codeflash_output = camel_to_kebab("ABC123DEF456") # 10.9μs -> 9.57μs (13.9% faster)

def test_edge_non_alpha_start():
    # String starting with a digit or symbol
    codeflash_output = camel_to_kebab("1CamelCase") # 9.97μs -> 8.74μs (14.1% faster)
    codeflash_output = camel_to_kebab("_CamelCase") # 4.01μs -> 3.47μs (15.6% faster)

def test_edge_unicode_emojis():
    # Unicode emoji should be preserved
    codeflash_output = camel_to_kebab("Smile😊Face") # 7.83μs -> 6.84μs (14.4% faster)

def test_edge_multiple_uppercase_at_start():
    # Multiple uppercase at start followed by lowercase
    codeflash_output = camel_to_kebab("XMLParser") # 9.62μs -> 8.46μs (13.6% faster)
    codeflash_output = camel_to_kebab("HTTPServer") # 4.04μs -> 3.51μs (15.3% faster)

def test_edge_uppercase_followed_by_number():
    # Uppercase followed by number
    codeflash_output = camel_to_kebab("VersionX2Update") # 11.1μs -> 9.24μs (20.4% faster)

# 3. LARGE SCALE TEST CASES

def test_large_long_string():
    # Large input string with many camel transitions
    long_camel = "A" + "".join(f"Test{i}Case" for i in range(1, 501))
    # Should start with 'a-test1-case-test2-case-...'
    expected = "a" + "".join(f"-test{i}-case" for i in range(1, 501))
    codeflash_output = camel_to_kebab(long_camel) # 619μs -> 619μs (0.014% slower)

def test_large_list_of_strings():
    # Test a list of 1000 camelCase strings
    inputs = [f"testCase{i}" for i in range(1000)]
    expected = [f"test-case{i}" for i in range(1000)]
    for inp, exp in zip(inputs, expected):
        codeflash_output = camel_to_kebab(inp) # 2.98ms -> 2.42ms (23.2% faster)

def test_large_acronym_handling():
    # Large string with repeated acronyms
    s = "HTTP" + "".join("XML" for _ in range(500)) + "Parser"
    expected = "http" + "".join("-xml" for _ in range(500)) + "-parser"
    codeflash_output = camel_to_kebab(s) # 20.3μs -> 19.0μs (6.34% faster)

def test_large_mixed_case():
    # Large mixed-case string with digits
    s = "".join(f"AbcDEF{i}GhiJKL" for i in range(1, 501))
    # Each group should split at D, G, J
    expected = "".join(f"abc-def{i}-ghi-jkl" for i in range(1, 501))
    codeflash_output = camel_to_kebab(s) # 1.36ms -> 1.38ms (0.888% slower)

def test_large_performance():
    # Performance: Should not take excessive time for 1000-element input
    import time
    start = time.time()
    for i in range(1000):
        camel_to_kebab(f"TestString{i}WithCamelCaseAndNumbers123") # 6.34ms -> 5.75ms (10.3% faster)
    elapsed = time.time() - start
# 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

# imports
import pytest  # used for our unit tests
from panel.util.__init__ import camel_to_kebab

# unit tests

# ----------------------
# 1. BASIC TEST CASES
# ----------------------

def test_simple_camel_case():
    # Basic camelCase conversion
    codeflash_output = camel_to_kebab("camelCase") # 10.3μs -> 9.04μs (13.7% faster)
    codeflash_output = camel_to_kebab("myVariableName") # 5.14μs -> 4.57μs (12.7% faster)
    codeflash_output = camel_to_kebab("testString") # 3.55μs -> 2.95μs (20.6% faster)
    codeflash_output = camel_to_kebab("anotherTest") # 3.36μs -> 2.73μs (23.1% faster)

def test_pascal_case():
    # PascalCase should also be converted correctly
    codeflash_output = camel_to_kebab("CamelCase") # 8.94μs -> 7.97μs (12.1% faster)
    codeflash_output = camel_to_kebab("MyVariableName") # 5.24μs -> 4.48μs (16.8% faster)
    codeflash_output = camel_to_kebab("TestString") # 3.45μs -> 3.00μs (15.2% faster)

def test_single_word_lowercase():
    # Single lowercase word should remain unchanged
    codeflash_output = camel_to_kebab("simple") # 6.35μs -> 5.14μs (23.6% faster)
    codeflash_output = camel_to_kebab("a") # 2.30μs -> 1.84μs (25.3% faster)

def test_single_word_uppercase():
    # Single uppercase word should become lowercase
    codeflash_output = camel_to_kebab("SIMPLE") # 7.22μs -> 5.90μs (22.4% faster)
    codeflash_output = camel_to_kebab("A") # 2.32μs -> 1.68μs (37.7% faster)

def test_numbers_in_string():
    # Numbers should be preserved and separated appropriately
    codeflash_output = camel_to_kebab("version2Number") # 10.1μs -> 8.85μs (14.5% faster)
    codeflash_output = camel_to_kebab("myVar123Test") # 5.46μs -> 4.68μs (16.7% faster)
    codeflash_output = camel_to_kebab("test123") # 2.63μs -> 2.11μs (24.8% faster)
    codeflash_output = camel_to_kebab("Test123Case") # 3.68μs -> 2.89μs (27.4% faster)

# ----------------------
# 2. EDGE TEST CASES
# ----------------------

def test_empty_string():
    # Empty string should return empty string
    codeflash_output = camel_to_kebab("") # 5.35μs -> 4.22μs (26.7% faster)

def test_all_uppercase():
    # All uppercase should become all lowercase
    codeflash_output = camel_to_kebab("ABC") # 6.65μs -> 5.26μs (26.4% faster)
    codeflash_output = camel_to_kebab("HTML") # 2.96μs -> 2.40μs (23.3% faster)

def test_leading_trailing_uppercase():
    # Leading and trailing uppercase letters
    codeflash_output = camel_to_kebab("ABCWord") # 9.01μs -> 8.10μs (11.3% faster)
    codeflash_output = camel_to_kebab("WordABC") # 5.17μs -> 4.15μs (24.7% faster)

def test_acronyms_and_initialisms():
    # Acronyms should be separated from following words
    codeflash_output = camel_to_kebab("getHTTPResponseCode") # 11.9μs -> 10.8μs (10.3% faster)
    codeflash_output = camel_to_kebab("parseXMLFile") # 4.82μs -> 4.41μs (9.51% faster)
    codeflash_output = camel_to_kebab("loadJSONData") # 4.19μs -> 3.47μs (20.7% faster)
    codeflash_output = camel_to_kebab("HTTPRequest") # 3.61μs -> 3.12μs (15.6% faster)
    codeflash_output = camel_to_kebab("URLParser") # 3.09μs -> 2.55μs (21.4% faster)

def test_multiple_consecutive_uppercase():
    # Multiple consecutive uppercase letters
    codeflash_output = camel_to_kebab("parseHTMLAndXML") # 11.1μs -> 10.0μs (11.2% faster)
    codeflash_output = camel_to_kebab("getABCTest") # 4.64μs -> 4.12μs (12.4% faster)
    codeflash_output = camel_to_kebab("getABCDEFTest") # 4.16μs -> 3.60μs (15.5% faster)

def test_already_kebab_case():
    # Already kebab-case should remain unchanged
    codeflash_output = camel_to_kebab("already-kebab-case") # 6.99μs -> 6.02μs (16.1% faster)

def test_non_alpha_characters():
    # Non-alphabetic characters should be preserved
    codeflash_output = camel_to_kebab("camelCase!") # 8.98μs -> 8.41μs (6.76% faster)
    codeflash_output = camel_to_kebab("test@String") # 3.40μs -> 2.77μs (23.1% faster)
    codeflash_output = camel_to_kebab("foo_Bar") # 2.52μs -> 2.06μs (22.4% faster)

def test_leading_trailing_hyphens():
    # Leading/trailing hyphens should be preserved
    codeflash_output = camel_to_kebab("-CamelCase-") # 9.11μs -> 7.96μs (14.4% faster)

def test_underscores():
    # Underscores should be preserved
    codeflash_output = camel_to_kebab("camel_Case") # 7.06μs -> 5.61μs (25.9% faster)
    codeflash_output = camel_to_kebab("Camel_Case") # 3.06μs -> 2.56μs (19.6% faster)

def test_unicode_characters():
    # Unicode letters should be handled correctly
    codeflash_output = camel_to_kebab("caféAuLait") # 10.8μs -> 9.41μs (14.4% faster)
    codeflash_output = camel_to_kebab("naïveBayes") # 4.52μs -> 3.75μs (20.7% faster)
    codeflash_output = camel_to_kebab("überCool") # 3.67μs -> 3.07μs (19.5% faster)

def test_digits_at_start_and_end():
    # Digits at the start or end should be preserved
    codeflash_output = camel_to_kebab("1CamelCase") # 10.1μs -> 9.00μs (12.1% faster)
    codeflash_output = camel_to_kebab("CamelCase2") # 4.36μs -> 3.72μs (17.2% faster)
    codeflash_output = camel_to_kebab("1CamelCase2") # 4.16μs -> 3.63μs (14.4% faster)

def test_mixed_case_and_numbers():
    # Mixed case and numbers
    codeflash_output = camel_to_kebab("parse2HTMLFiles") # 10.5μs -> 9.47μs (10.7% faster)
    codeflash_output = camel_to_kebab("HTML5Parser") # 5.42μs -> 4.71μs (15.2% faster)

def test_long_acronym_followed_by_word():
    codeflash_output = camel_to_kebab("SVGImage") # 8.84μs -> 7.70μs (14.9% faster)
    codeflash_output = camel_to_kebab("PDFDocument") # 4.08μs -> 3.47μs (17.4% faster)

# ----------------------
# 3. LARGE SCALE TEST CASES
# ----------------------

def test_long_string_performance():
    # Test with a long camelCase string (repeated pattern)
    long_camel = "ThisIsAReallyLongCamelCaseString" * 20  # length ~700
    expected = "-".join([
        "this", "is", "a", "really", "long", "camel", "case", "string"
    ] * 20)
    codeflash_output = camel_to_kebab(long_camel) # 106μs -> 105μs (0.709% faster)


def test_large_mixed_case_string():
    # Test a string with alternating upper/lowercase and digits, repeated
    pattern = "AbC1dEfG2"
    large_string = pattern * 100
    # Manually convert one pattern for expected output
    # AbC1dEfG2 -> ab-c1d-ef-g2
    expected_pattern = "ab-c1d-ef-g2"
    expected = expected_pattern * 100
    codeflash_output = camel_to_kebab(large_string) # 217μs -> 215μs (0.649% faster)

def test_long_acronym_in_large_string():
    # Test a string with a long acronym in the middle
    s = "start" + "ABCDEF" * 100 + "end"
    # Should become: start-abcdef-abcdef-...-abcdef-end
    expected = "start" + ("-abcdef" * 100) + "-end"
    codeflash_output = camel_to_kebab(s) # 16.1μs -> 15.0μs (7.43% faster)

def test_large_unicode_string():
    # Test a long string with unicode characters and camelCase
    base = "ÜberCoolÉclairNaïveBayes"
    long_unicode = base * 50
    expected = "-".join([
        "über", "cool", "éclair", "naïve", "bayes"
    ] * 50)
    codeflash_output = camel_to_kebab(long_unicode) # 118μs -> 116μs (1.49% 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-camel_to_kebab-mha4wbws and push.