⚡️ Speed up method FeatureRegistryClientWithOverride.feature_path by 268%

[codeflash-ai]

📄 268% (2.68x) speedup for FeatureRegistryClientWithOverride.feature_path in google/cloud/aiplatform/utils/__init__.py

⏱️ Runtime : 2.34 milliseconds → 636 microseconds (best of 234 runs)

📝 Explanation and details

The optimized code replaces the .format() method with an f-string for string formatting, achieving a 268% speedup.

Key optimization: The original code uses str.format() with named parameters, which involves:

1. Parsing the format string to find placeholders
2. Creating keyword arguments dictionary
3. Performing multiple dictionary lookups during substitution

The f-string optimization eliminates this overhead by:

• Using compile-time string interpolation instead of runtime formatting
• Direct variable substitution without dictionary operations
• Avoiding the method call overhead of .format()

Performance impact: Line profiler shows the total execution time dropped from 5.65ms to 1.77ms. The f-string approach reduces per-hit time from ~490ns to ~335ns for the main formatting operation.

Test case performance: The optimization is most effective for:

• Simple string inputs (250-300% faster): Most common use case with typical project/location names
• Special characters and Unicode (150-350% faster): f-strings handle these more efficiently
• High-frequency calls (270%+ faster): The performance gain compounds when called repeatedly
• Non-string types (45-120% faster): Even with type coercion, f-strings still outperform .format()

This optimization is particularly valuable since feature_path() is likely called frequently in ML pipeline operations where path generation is a common bottleneck.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from aiplatform.utils.__init__ import FeatureRegistryClientWithOverride

# 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.
#

# Minimal stub for dependencies
class ClientWithOverride:
    pass

class FeatureRegistryServiceClientV1:
    pass

class FeatureRegistryServiceClientV1Beta1:
    pass

class CompatStub:
    V1 = "v1"
    V1BETA1 = "v1beta1"
    DEFAULT_VERSION = "v1"

compat = CompatStub()
from aiplatform.utils.__init__ import FeatureRegistryClientWithOverride

# unit tests

# Helper alias for test clarity
feature_path = FeatureRegistryClientWithOverride.feature_path

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

def test_basic_typical_strings():
    # Typical input values
    codeflash_output = feature_path("my-project", "us-central1", "groupA", "featureX"); result = codeflash_output # 1.53μs -> 429ns (257% faster)

def test_basic_numeric_strings():
    # Numeric values as strings
    codeflash_output = feature_path("123", "456", "789", "101112"); result = codeflash_output # 1.50μs -> 449ns (235% faster)

def test_basic_mixed_alphanumeric():
    # Mixed alphanumeric values
    codeflash_output = feature_path("proj42", "loc-2", "grp_01", "feat99"); result = codeflash_output # 1.53μs -> 431ns (256% faster)

def test_basic_special_characters():
    # Special characters in the input
    codeflash_output = feature_path("proj!@#", "loc$%^", "grp&*()", "feat[]{}"); result = codeflash_output # 1.57μs -> 409ns (285% faster)

def test_basic_unicode_characters():
    # Unicode characters (non-ASCII)
    codeflash_output = feature_path("项目", "位置", "组", "特征"); result = codeflash_output # 2.11μs -> 841ns (151% faster)

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

def test_edge_empty_strings():
    # All parameters are empty strings
    codeflash_output = feature_path("", "", "", ""); result = codeflash_output # 1.52μs -> 384ns (296% faster)

def test_edge_some_empty_strings():
    # Some parameters are empty
    codeflash_output = feature_path("proj", "", "grp", ""); result = codeflash_output # 1.56μs -> 431ns (261% faster)

def test_edge_long_strings():
    # Very long strings (max 1000 chars)
    long_str = "a" * 1000
    codeflash_output = feature_path(long_str, long_str, long_str, long_str); result = codeflash_output # 2.18μs -> 748ns (192% faster)
    expected = f"projects/{long_str}/locations/{long_str}/featureGroups/{long_str}/features/{long_str}"

def test_edge_strings_with_slash():
    # Strings containing slashes
    codeflash_output = feature_path("proj/ect", "loc/ation", "group/one", "feature/two"); result = codeflash_output # 1.51μs -> 422ns (258% faster)

def test_edge_strings_with_whitespace():
    # Strings containing whitespace
    codeflash_output = feature_path("proj ect", "loc ation", "group one", "feature two"); result = codeflash_output # 1.45μs -> 400ns (262% faster)

def test_edge_strings_with_newline_and_tab():
    # Strings containing newline and tab characters
    codeflash_output = feature_path("proj\nect", "loc\tation", "group\none", "feature\ttwo"); result = codeflash_output # 1.52μs -> 388ns (292% faster)


def test_edge_non_string_types():
    # Passing non-string types (int, float, bool, list, dict)
    # Should be converted to string by format
    codeflash_output = feature_path(123, 45.6, True, ["f"]); result = codeflash_output
    codeflash_output = feature_path({"p":1}, (2,3), None, False); result = codeflash_output
    # None will raise AttributeError
    with pytest.raises(AttributeError):
        feature_path("proj", "loc", "grp", None)

def test_edge_format_string_injection():
    # Inputs containing curly braces
    codeflash_output = feature_path("{project}", "{location}", "{group}", "{feature}"); result = codeflash_output # 2.48μs -> 557ns (346% faster)

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

def test_large_scale_many_unique_calls():
    # Test with many unique calls to ensure no caching/memoization bugs
    for i in range(1000):
        codeflash_output = feature_path(f"proj{i}", f"loc{i}", f"group{i}", f"feature{i}"); result = codeflash_output # 646μs -> 172μs (274% faster)
        expected = f"projects/proj{i}/locations/loc{i}/featureGroups/group{i}/features/feature{i}"

def test_large_scale_long_strings():
    # Use long strings for each parameter, but keep total < 1000 chars
    base = "x" * 250
    codeflash_output = feature_path(base, base, base, base); result = codeflash_output # 2.75μs -> 669ns (311% faster)
    expected = f"projects/{base}/locations/{base}/featureGroups/{base}/features/{base}"

def test_large_scale_all_ascii_printable():
    # Use all printable ASCII characters in each parameter
    import string
    chars = string.printable
    codeflash_output = feature_path(chars, chars, chars, chars); result = codeflash_output # 1.88μs -> 498ns (278% faster)
    expected = f"projects/{chars}/locations/{chars}/featureGroups/{chars}/features/{chars}"

def test_large_scale_parameter_collision():
    # All parameters have the same value, repeated many times
    for i in range(1000):
        val = f"val{i}"
        codeflash_output = feature_path(val, val, val, val); result = codeflash_output # 643μs -> 171μs (274% faster)
        expected = f"projects/{val}/locations/{val}/featureGroups/{val}/features/{val}"

def test_large_scale_parameter_variation():
    # Each parameter is a different length, up to 1000 elements
    for i in range(1, 1001, 250):
        p = "p" * i
        l = "l" * (1001 - i)
        g = "g" * (i // 2)
        f = "f" * (1001 - i // 2)
        codeflash_output = feature_path(p, l, g, f); result = codeflash_output # 5.98μs -> 1.76μs (240% faster)
        expected = f"projects/{p}/locations/{l}/featureGroups/{g}/features/{f}"

# --------------------------
# Additional Edge Cases
# --------------------------

def test_edge_parameter_is_boolean():
    # Boolean values as parameters
    codeflash_output = feature_path(True, False, True, False); result = codeflash_output # 2.50μs -> 1.21μs (106% faster)

def test_edge_parameter_is_object():
    # Custom object as parameter
    class Dummy:
        def __str__(self):
            return "dummy"
    dummy = Dummy()
    codeflash_output = feature_path(dummy, dummy, dummy, dummy); result = codeflash_output # 2.44μs -> 1.11μs (120% faster)

def test_edge_parameter_is_bytes():
    # Bytes as parameter
    codeflash_output = feature_path(b"bytes", b"bytes", b"bytes", b"bytes"); result = codeflash_output # 2.03μs -> 966ns (110% faster)
    # str(b"bytes") == "b'bytes'"
    expected = "projects/b'bytes'/locations/b'bytes'/featureGroups/b'bytes'/features/b'bytes'"

def test_edge_parameter_is_tuple():
    # Tuple as parameter
    codeflash_output = feature_path(("a",), ("b",), ("c",), ("d",)); result = codeflash_output # 3.26μs -> 2.21μs (47.3% faster)
    expected = "projects/('a',)/locations/('b',)/featureGroups/('c',)/features/('d',)"

def test_edge_parameter_is_list():
    # List as parameter
    codeflash_output = feature_path(["a"], ["b"], ["c"], ["d"]); result = codeflash_output # 2.76μs -> 1.52μs (81.6% faster)
    expected = "projects/['a']/locations/['b']/featureGroups/['c']/features/['d']"

def test_edge_parameter_is_dict():
    # Dict as parameter
    codeflash_output = feature_path({"k": "v"}, {"k": "v"}, {"k": "v"}, {"k": "v"}); result = codeflash_output # 3.04μs -> 1.93μs (57.1% faster)
    expected = "projects/{'k': 'v'}/locations/{'k': 'v'}/featureGroups/{'k': 'v'}/features/{'k': 'v'}"

def test_edge_parameter_is_float():
    # Float as parameter
    codeflash_output = feature_path(1.23, 4.56, 7.89, 0.12); result = codeflash_output # 3.74μs -> 2.92μs (28.3% faster)
    expected = "projects/1.23/locations/4.56/featureGroups/7.89/features/0.12"
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from aiplatform.utils.__init__ import FeatureRegistryClientWithOverride

# unit tests

# Basic Test Cases
def test_feature_path_basic():
    # Test with typical string inputs
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "my_project", "us-central1", "customer_data", "age"
    ); result = codeflash_output # 1.85μs -> 485ns (281% faster)

def test_feature_path_basic_numbers():
    # Test with numeric strings
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "123", "456", "789", "012"
    ); result = codeflash_output # 1.64μs -> 429ns (282% faster)

def test_feature_path_basic_mixed():
    # Test with mixed alphanumeric strings
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "proj1", "loc2", "fg3", "f4"
    ); result = codeflash_output # 1.55μs -> 425ns (265% faster)

# Edge Test Cases

def test_feature_path_empty_strings():
    # Test with all empty strings
    codeflash_output = FeatureRegistryClientWithOverride.feature_path("", "", "", ""); result = codeflash_output # 1.60μs -> 403ns (297% faster)

def test_feature_path_partial_empty():
    # Test with some empty strings
    codeflash_output = FeatureRegistryClientWithOverride.feature_path("proj", "", "fg", ""); result = codeflash_output # 1.56μs -> 438ns (256% faster)

def test_feature_path_special_chars():
    # Test with special characters in parameters
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "pr@j#ct", "loc$%^", "fg*&", "feat()"
    ); result = codeflash_output # 1.56μs -> 426ns (267% faster)

def test_feature_path_unicode():
    # Test with unicode characters
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "项目", "位置", "特征组", "特征"
    ); result = codeflash_output # 2.10μs -> 837ns (151% faster)

def test_feature_path_whitespace():
    # Test with whitespace in parameters
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "my project", "us central1", "customer data", "age years"
    ); result = codeflash_output # 1.53μs -> 404ns (279% faster)

def test_feature_path_long_strings():
    # Test with very long strings
    long_str = "a" * 256
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        long_str, long_str, long_str, long_str
    ); result = codeflash_output # 2.33μs -> 654ns (256% faster)
    expected = (
        f"projects/{long_str}/locations/{long_str}/featureGroups/{long_str}/features/{long_str}"
    )

def test_feature_path_reserved_words():
    # Test with reserved words as parameters
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "class", "def", "return", "import"
    ); result = codeflash_output # 1.60μs -> 416ns (284% faster)

def test_feature_path_none_as_string():
    # Test with the string "None" as parameter
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "None", "None", "None", "None"
    ); result = codeflash_output # 1.46μs -> 401ns (264% faster)

# Large Scale Test Cases

def test_feature_path_large_scale_unique():
    # Test with 1000 unique feature names to check scalability and uniqueness
    base_project = "proj"
    base_location = "loc"
    base_group = "group"
    for i in range(1000):
        feature = f"feature_{i}"
        codeflash_output = FeatureRegistryClientWithOverride.feature_path(
            base_project, base_location, base_group, feature
        ); path = codeflash_output # 645μs -> 172μs (274% faster)
        expected = f"projects/{base_project}/locations/{base_location}/featureGroups/{base_group}/features/{feature}"

def test_feature_path_large_scale_long_names():
    # Test with long feature group and feature names
    long_group = "group_" + "x" * 900
    long_feature = "feature_" + "y" * 900
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "project", "location", long_group, long_feature
    ); path = codeflash_output # 2.43μs -> 804ns (202% faster)
    expected = f"projects/project/locations/location/featureGroups/{long_group}/features/{long_feature}"

def test_feature_path_large_scale_varied_inputs():
    # Test with varied inputs in a loop (under 1000 iterations)
    for i in range(500):
        project = f"proj{i}"
        location = f"loc{i%10}"
        group = f"group{i%100}"
        feature = f"feature{i%250}"
        codeflash_output = FeatureRegistryClientWithOverride.feature_path(
            project, location, group, feature
        ); path = codeflash_output # 324μs -> 86.9μs (273% faster)
        expected = f"projects/{project}/locations/{location}/featureGroups/{group}/features/{feature}"

# Additional Edge Cases

def test_feature_path_leading_trailing_spaces():
    # Test with leading/trailing spaces
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        " project ", " location ", " group ", " feature "
    ); result = codeflash_output # 1.56μs -> 438ns (256% faster)

def test_feature_path_escape_sequences():
    # Test with escape sequences
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "proj\n", "loc\t", "group\r", "feature\b"
    ); result = codeflash_output # 1.41μs -> 367ns (285% faster)

def test_feature_path_slash_in_name():
    # Test with slashes in parameters
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "my/project", "us/central1", "customer/data", "age/years"
    ); result = codeflash_output # 1.49μs -> 358ns (315% faster)

def test_feature_path_dash_underscore():
    # Test with dashes and underscores
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        "my-project", "us_central1", "customer-data", "age_years"
    ); result = codeflash_output # 1.47μs -> 396ns (271% faster)

# Type Error Cases

def test_feature_path_non_string_types():
    # Test with non-string types (should coerce to string)
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(
        123, 456.789, True, None
    ); result = codeflash_output # 4.04μs -> 2.80μs (44.5% faster)

def test_feature_path_object_types():
    # Test with objects that implement __str__
    class Dummy:
        def __str__(self):
            return "dummy"
    dummy = Dummy()
    codeflash_output = FeatureRegistryClientWithOverride.feature_path(dummy, dummy, dummy, dummy); result = codeflash_output # 2.52μs -> 1.21μs (108% 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-FeatureRegistryClientWithOverride.feature_path-mgklcndy and push.