⚡️ Speed up function convert_camel_case_resource_noun_to_snake_case by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for convert_camel_case_resource_noun_to_snake_case in google/cloud/aiplatform/utils/__init__.py

⏱️ Runtime : 4.06 milliseconds → 3.60 milliseconds (best of 164 runs)

📝 Explanation and details

The optimized code achieves a 12% speedup by pre-compiling the regex pattern at module scope instead of compiling it on every function call.

Key optimization:

• Regex pre-compilation: _CAMEL_TO_SNAKE_RE = re.compile(r"([A-Z]+)") is created once when the module loads, rather than calling re.sub("([A-Z]+)", ...) which compiles the pattern every time the function runs.

Why this improves performance:
In Python's re module, every call to re.sub() with a string pattern must first compile that pattern into a regex object. By pre-compiling the pattern once and reusing the compiled object via _CAMEL_TO_SNAKE_RE.sub(), we eliminate this repeated compilation overhead.

The line profiler shows the regex substitution line dropped from 11.9ms to 10.2ms (14% reduction), which represents 93% of the original function's total time. This optimization is particularly effective because:

• The same regex pattern ([A-Z]+) is used repeatedly across all function calls
• Regex compilation has fixed overhead regardless of input size
• The function is called frequently (1377 times in the profiler)

Test case benefits:

• Basic conversions (single/multi-word): 12-21% faster
• Large-scale tests with long strings: 10-15% faster
• Edge cases with special characters: Up to 30% faster for simple cases
• Batch processing: 15% improvement when processing many strings

The optimization maintains identical behavior while providing consistent performance gains across all input types.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

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

# imports
import pytest  # used for our unit tests
from aiplatform.utils.__init__ import \
    convert_camel_case_resource_noun_to_snake_case

# function to test
# -*- coding: utf-8 -*-

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


_SINGULAR_RESOURCE_NOUNS = {"time_series"}
_SINGULAR_RESOURCE_NOUNS_MAP = {"indexes": "index"}
from aiplatform.utils.__init__ import \
    convert_camel_case_resource_noun_to_snake_case

# unit tests

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

@pytest.mark.parametrize(
    "input_str,expected",
    [
        # Single word, singular
        ("Book", "book"),
        ("Index", "index"),
        ("TimeSeries", "time_series"),
        ("User", "user"),
        # Single word, plural
        ("Books", "book"),
        ("Indexes", "index"),
        ("Users", "user"),
        # Multi-word camel case
        ("BookShelf", "book_shelf"),
        ("UserProfile", "user_profile"),
        ("TimeSeries", "time_series"),
        ("BookShelves", "book_shelve"),  # not in singular map, just drops 's'
        # Multi-word, plural
        ("UserProfiles", "user_profile"),
        ("BookShelves", "book_shelve"),
        # Acronym in camel case
        ("IPAddress", "i_p_address"),
        ("IPAddresss", "i_p_address"),  # not plural, just 's' at end
        ("IPAddresses", "i_p_addresse"),
        ("HTTPRequest", "h_t_t_p_request"),
        ("HTTPRequestS", "h_t_t_p_request"),  # edge: not plural, just 's'
        # Already snake_case
        ("time_series", "time_series"),
        ("user_profile", "user_profile"),
    ]
)
def test_basic_cases(input_str, expected):
    """Test basic and typical cases for camel to snake conversion and singularization."""
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(input_str) # 132μs -> 118μs (12.1% faster)

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

@pytest.mark.parametrize(
    "input_str,expected",
    [
        # Empty string
        ("", ""),
        # Single letter
        ("A", "a"),
        ("S", "s"),
        # All uppercase
        ("BOOKS", "b_o_o_k_s"),
        ("INDEXES", "i_n_d_e_x_e_s"),
        # All lowercase
        ("books", "books"),
        ("indexes", "index"),
        # Already snake_case, plural
        ("user_profiles", "user_profile"),
        ("time_series", "time_series"),
        ("indexes", "index"),
        # Trailing 's' but not plural
        ("Glass", "glass"),
        ("Boss", "bos"),  # drops 's'
        ("Class", "clas"),  # drops 's'
        # Words ending in 'ies'
        ("Companies", "companie"),
        ("Libraries", "librarie"),
        # Words ending in 'ss'
        ("Address", "address"),
        ("Addresses", "addresse"),
        # Numbers in input
        ("Book2", "book2"),
        ("Book2s", "book2"),
        ("User1Profiles", "user1_profile"),
        # Non-alphabetic
        ("Book$", "book$"),
        ("Book$s", "book$"),
        ("Book_Shelf", "book_shelf"),
        # Leading/trailing underscores
        ("_Book", "_book"),
        ("Book_", "book_"),
        ("_Books", "_book"),
        ("Books_", "book_"),
        # Multiple consecutive capitals
        ("XMLParser", "x_m_l_parser"),
        ("XMLParsers", "x_m_l_parser"),
        ("HTTPRequest", "h_t_t_p_request"),
        ("HTTPRequestS", "h_t_t_p_request"),
        # Plural noun in singular exceptions
        ("TimeSeries", "time_series"),
        ("TimeSeriess", "time_serie"),
        # Plural noun in mapping
        ("Indexes", "index"),
        ("indexes", "index"),
        # Plural noun not in mapping or exceptions
        ("Cats", "cat"),
        ("Dogs", "dog"),
        # Input is only underscores
        ("_", "_"),
        ("__", "__"),
        # Input is only numbers
        ("123", "123"),
        ("123s", "123"),
        # Input is only special characters
        ("$", "$"),
        ("$s", "$"),
    ]
)
def test_edge_cases(input_str, expected):
    """Test edge cases, including empty, single char, all caps, numbers, special chars, etc."""
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(input_str) # 257μs -> 231μs (11.2% faster)

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

def test_large_scale_single_word():
    """Test conversion of a very long single camel case word."""
    # Create a long camel case word: "WordWordWord...Word" (100 times)
    camel = "Word" * 100
    expected = "_".join(["word"] * 100)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 57.3μs -> 55.3μs (3.57% faster)

def test_large_scale_multi_word():
    """Test conversion of a very long multi-word camel case string."""
    # "BookShelfUserProfile" * 50
    camel = "BookShelfUserProfile" * 50
    expected = "_".join(["book", "shelf", "user", "profile"] * 50)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 105μs -> 105μs (0.523% faster)

def test_large_scale_plural():
    """Test conversion and singularization of a large plural camel case string."""
    # "Bookshelves" * 100
    camel = "Bookshelves" * 100
    # Each 'Bookshelves' -> 'bookshelves' -> 'bookshelve' (drops 's')
    expected = "_".join(["bookshelve"] * 100)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 60.4μs -> 60.1μs (0.566% faster)

def test_large_scale_all_caps():
    """Test a large all-caps string."""
    # "XML" * 300
    camel = "XML" * 300
    # Each 'XML' -> 'x_m_l'
    expected = "_".join(["x", "m", "l"] * 300)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 7.99μs -> 7.25μs (10.1% faster)

def test_large_scale_numbers_and_letters():
    """Test a large string with numbers and letters."""
    # "Book1Shelf2User3" * 50
    camel = "Book1Shelf2User3" * 50
    expected = "_".join(["book1", "shelf2", "user3"] * 50)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 75.5μs -> 75.8μs (0.331% slower)

def test_large_scale_mixed_case():
    """Test a large string with mixed case and underscores."""
    # "User_Profile" * 100
    camel = "User_Profile" * 100
    expected = "_".join(["user_profile"] * 100)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 101μs -> 100μs (0.447% faster)

def test_large_scale_special_characters():
    """Test a large string with special characters."""
    # "Book$Shelf#User!" * 50
    camel = "Book$Shelf#User!" * 50
    expected = "_".join(["book$", "shelf#", "user!"] * 50)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 75.6μs -> 75.0μs (0.826% faster)

def test_large_scale_alphabet():
    """Test all uppercase and lowercase letters concatenated."""
    camel = "".join([c.upper() for c in string.ascii_lowercase])
    # Each capital triggers an underscore, so expected is: '_a_b_c_..._z'
    expected = "_" + "_".join([c for c in string.ascii_lowercase])
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 5.63μs -> 4.90μs (14.8% faster)

# --------------------
# Determinism and Idempotency
# --------------------

@pytest.mark.parametrize(
    "input_str",
    [
        "Book",
        "BookShelf",
        "BookShelves",
        "UserProfile",
        "TimeSeries",
        "Indexes",
        "Books",
        "Book2s",
        "XMLParser",
        "HTTPRequest",
        "User_Profile",
        "user_profile",
        "",
        "123s",
        "Book$",
        "Book_Shelf",
    ]
)
def test_idempotency(input_str):
    """Test that applying the function twice does not change the result (idempotency)."""
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(input_str); once = codeflash_output # 94.9μs -> 82.7μs (14.8% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(once); twice = codeflash_output # 33.5μs -> 26.6μs (25.6% faster)

# --------------------
# Type Safety
# --------------------

def test_non_string_input_raises():
    """Test that non-string input raises an exception."""
    with pytest.raises(TypeError):
        convert_camel_case_resource_noun_to_snake_case(None) # 3.71μs -> 2.99μs (24.1% faster)
    with pytest.raises(TypeError):
        convert_camel_case_resource_noun_to_snake_case(123) # 2.36μs -> 1.81μs (30.5% faster)
    with pytest.raises(TypeError):
        convert_camel_case_resource_noun_to_snake_case(["Book"]) # 1.81μs -> 1.37μs (32.2% faster)
    with pytest.raises(TypeError):
        convert_camel_case_resource_noun_to_snake_case({'Book': 'Book'}) # 1.61μs -> 1.28μs (25.1% 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 aiplatform.utils.__init__ import \
    convert_camel_case_resource_noun_to_snake_case

# function to test
# -*- coding: utf-8 -*-

# Copyright 2023 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


# Resource nouns that are not plural in their resource names.
# Used below to avoid conversion from plural to singular.
_SINGULAR_RESOURCE_NOUNS = {"time_series"}
_SINGULAR_RESOURCE_NOUNS_MAP = {"indexes": "index"}
from aiplatform.utils.__init__ import \
    convert_camel_case_resource_noun_to_snake_case

# unit tests

# --- BASIC TEST CASES ---

def test_single_word_camel_case():
    # Should convert a single word CamelCase to snake_case and singularize if needed
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Book") # 6.46μs -> 5.73μs (12.9% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Books") # 3.56μs -> 2.96μs (20.2% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Index") # 2.29μs -> 1.95μs (16.9% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Indexes") # 2.26μs -> 1.87μs (21.0% faster)

def test_multi_word_camel_case():
    # Should convert multi-word CamelCase to snake_case and singularize if needed
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfile") # 6.84μs -> 6.23μs (9.81% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfiles") # 3.90μs -> 3.21μs (21.4% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("TimeSeries") # 2.89μs -> 2.53μs (14.4% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("EventLogs") # 2.79μs -> 2.39μs (16.8% faster)

def test_lowercase_input():
    # Should handle already lowercase input gracefully
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("book") # 3.71μs -> 3.13μs (18.5% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("books") # 2.17μs -> 1.83μs (18.0% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("index") # 1.52μs -> 1.20μs (26.8% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("indexes") # 1.70μs -> 1.41μs (20.5% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("user_profile") # 1.50μs -> 1.30μs (16.0% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("user_profiles") # 1.61μs -> 1.34μs (20.7% faster)

def test_already_snake_case():
    # Should not modify already snake_case input except for singularization
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("event_log") # 3.74μs -> 3.17μs (17.8% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("event_logs") # 2.16μs -> 1.88μs (15.2% faster)

# --- EDGE TEST CASES ---

def test_empty_string():
    # Should handle empty string gracefully
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("") # 3.31μs -> 2.61μs (27.2% faster)

def test_single_letter():
    # Should handle single letter inputs
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("A") # 5.62μs -> 4.93μs (13.9% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("a") # 2.17μs -> 1.57μs (38.1% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("S") # 2.77μs -> 2.17μs (27.2% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("s") # 1.50μs -> 1.28μs (16.9% faster)

def test_acronyms_and_uppercase():
    # Should handle acronyms and consecutive uppercase letters
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("XMLDocument") # 6.02μs -> 5.40μs (11.4% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("XMLDocuments") # 3.60μs -> 2.92μs (23.3% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("HTTPRequest") # 2.43μs -> 1.89μs (29.0% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("HTTPRequestS") # 3.02μs -> 2.72μs (11.4% faster)

def test_trailing_and_leading_underscores():
    # Should handle leading/trailing underscores in snake_case
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("_Books") # 5.98μs -> 5.28μs (13.2% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Books_") # 3.11μs -> 2.60μs (19.7% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("_UserProfiles_") # 3.22μs -> 3.02μs (6.83% faster)

def test_resource_noun_in_singular_exceptions():
    # Should not singularize resource nouns in _SINGULAR_RESOURCE_NOUNS
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("TimeSeries") # 6.55μs -> 5.88μs (11.5% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("time_series") # 2.29μs -> 1.86μs (23.1% faster)

def test_resource_noun_in_singular_map():
    # Should use _SINGULAR_RESOURCE_NOUNS_MAP for special cases
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Indexes") # 5.93μs -> 5.12μs (15.6% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("indexes") # 2.34μs -> 1.93μs (21.5% faster)

def test_non_plural_endings():
    # Should not singularize words ending with 's' that are not plural
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Glass") # 5.74μs -> 5.12μs (12.2% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("class") # 2.21μs -> 1.79μs (23.7% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Class") # 2.74μs -> 2.32μs (18.0% faster)

def test_non_alpha_characters():
    # Should handle resource nouns with non-alpha characters
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfile2") # 6.68μs -> 5.98μs (11.7% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfiles2") # 3.50μs -> 2.94μs (19.3% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("DataSet_V2") # 3.41μs -> 3.04μs (12.3% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("DataSets_V2") # 3.08μs -> 2.85μs (8.25% faster)

def test_mixed_case_input():
    # Should handle mixed case input
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("userProfileS") # 6.79μs -> 5.95μs (14.1% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserprofileS") # 3.53μs -> 3.01μs (17.3% faster)

def test_input_with_numbers():
    # Should handle numbers in the input
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Book2") # 5.44μs -> 4.83μs (12.6% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("Books2") # 2.85μs -> 2.38μs (19.8% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfile2023") # 3.19μs -> 2.81μs (13.3% faster)
    codeflash_output = convert_camel_case_resource_noun_to_snake_case("UserProfiles2023") # 2.65μs -> 2.40μs (10.2% faster)

# --- LARGE SCALE TEST CASES ---

def test_large_batch_conversion():
    # Should handle a large batch of resource nouns efficiently and correctly
    # Generate 500 camel case resource nouns with plural and singular forms
    for i in range(1, 501):
        singular = f"ResourceNoun{i}"
        plural = f"ResourceNouns{i}"
        # Singular conversion
        codeflash_output = convert_camel_case_resource_noun_to_snake_case(singular) # 1.16ms -> 1.01ms (14.8% faster)
        # Plural conversion
        codeflash_output = convert_camel_case_resource_noun_to_snake_case(plural)

def test_long_resource_noun():
    # Should handle very long resource noun strings
    long_camel = "SuperLongResourceNounNameWithManyPartsAndNumbers12345"
    long_snake = "super_long_resource_noun_name_with_many_parts_and_numbers12345"
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(long_camel) # 13.7μs -> 12.4μs (10.2% faster)

    long_plural_camel = "SuperLongResourceNounNamesWithManyPartsAndNumbers12345"
    long_plural_snake = "super_long_resource_noun_name_with_many_parts_and_numbers12345"
    codeflash_output = convert_camel_case_resource_noun_to_snake_case(long_plural_camel) # 7.81μs -> 7.21μs (8.23% faster)

def test_large_acronym_resource_nouns():
    # Should handle resource nouns with long acronyms
    for i in range(1, 101):
        camel = f"APIResourceNoun{i}"
        plural = f"APIResourceNouns{i}"
        expected_singular = f"a_p_i_resource_noun{i}"
        codeflash_output = convert_camel_case_resource_noun_to_snake_case(camel) # 241μs -> 210μs (14.5% faster)
        codeflash_output = convert_camel_case_resource_noun_to_snake_case(plural)

def test_batch_with_edge_cases():
    # Should handle a batch of edge-case resource nouns
    resource_nouns = [
        "", "A", "S", "Book", "Books", "Indexes", "TimeSeries", "Glass", "Class",
        "UserProfile2", "UserProfiles2", "DataSet_V2", "DataSets_V2", "XMLDocument",
        "XMLDocuments", "HTTPRequest", "HTTPRequestS", "userProfileS", "UserprofileS",
        "Book2", "Books2", "UserProfile2023", "UserProfiles2023"
    ]
    expected = [
        "", "a", "s", "book", "book", "index", "time_series", "glass", "class",
        "user_profile2", "user_profile2", "data_set__v2", "data_set__v2", "x_m_l_document",
        "x_m_l_document", "h_t_t_p_request", "h_t_t_p_request", "user_profile", "userprofile",
        "book2", "book2", "user_profile2023", "user_profile2023"
    ]
    for noun, exp in zip(resource_nouns, expected):
        codeflash_output = convert_camel_case_resource_noun_to_snake_case(noun) # 57.7μs -> 49.7μs (16.1% 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-convert_camel_case_resource_noun_to_snake_case-mgkkldbs and push.