⚡️ Speed up function construct_model_type_cache_path by 33%

[codeflash-ai]

📄 33% (0.33x) speedup for construct_model_type_cache_path in inference/core/registries/roboflow.py

⏱️ Runtime : 3.20 milliseconds → 2.41 milliseconds (best of 107 runs)

📝 Explanation and details

The optimized version achieves a 32% speedup by eliminating redundant os.path.join() calls and intermediate variable creation.

Key optimization: Instead of creating an intermediate cache_dir variable and making two separate os.path.join() calls, the optimized code performs a single os.path.join() call with all path components at once.

Original approach:

1. Creates cache_dir with os.path.join(MODEL_CACHE_DIR, dataset_id, version_id or "")
2. Makes second os.path.join(cache_dir, "model_type.json") call

Optimized approach:

1. Directly calls os.path.join() once with all components: (MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
2. Uses conditional logic to handle the None version_id case cleanly

Why this is faster:

• Reduces function call overhead (1 vs 2 os.path.join() calls)
• Eliminates intermediate string object creation (cache_dir)
• Reduces memory allocations and string concatenations

Test performance: The optimization shows consistent 25-55% improvements across all test cases, with particularly strong gains when version_id is None or empty (up to 54% faster). Large-scale tests with 100-1000 iterations show 28-48% speedups, demonstrating the optimization scales well with volume.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os

# imports
import pytest  # used for our unit tests
from inference.core.registries.roboflow import construct_model_type_cache_path

# function to test
# Simulate the external dependencies for testing purposes
MODEL_CACHE_DIR = "/tmp/model_cache"  # Simulate env var
from inference.core.registries.roboflow import construct_model_type_cache_path

# unit tests

# -------------------------------
# 1. Basic Test Cases
# -------------------------------

def test_basic_with_version():
    # Basic case: both dataset_id and version_id provided
    dataset_id = "ds123"
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.07μs -> 1.52μs (36.0% faster)

def test_basic_without_version():
    # Basic case: version_id is None
    dataset_id = "ds456"
    version_id = None
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "", "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.07μs -> 1.51μs (37.5% faster)

def test_basic_with_empty_version():
    # Basic case: version_id is empty string
    dataset_id = "ds789"
    version_id = ""
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "", "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 1.97μs -> 1.50μs (31.8% faster)

def test_basic_with_model_id():
    # Basic case: using model_id instead of dataset_id
    model_id = "modelABC"
    version_id = "v2"
    expected = os.path.join(MODEL_CACHE_DIR, model_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(model_id, version_id); result = codeflash_output # 1.98μs -> 1.49μs (33.1% faster)

# -------------------------------
# 2. Edge Test Cases
# -------------------------------

def test_edge_dataset_id_empty_string():
    # Edge case: dataset_id is empty string
    dataset_id = ""
    version_id = "v3"
    expected = os.path.join(MODEL_CACHE_DIR, "", version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 1.97μs -> 1.53μs (28.7% faster)

def test_edge_both_empty_strings():
    # Edge case: both dataset_id and version_id are empty strings
    dataset_id = ""
    version_id = ""
    expected = os.path.join(MODEL_CACHE_DIR, "", "", "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 1.96μs -> 1.31μs (49.8% faster)

def test_edge_special_characters():
    # Edge case: dataset_id and version_id contain special characters
    dataset_id = "ds!@#$%^&*()"
    version_id = "v?/\\|<>:\""
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 1.98μs -> 1.55μs (27.8% faster)

def test_edge_unicode_characters():
    # Edge case: dataset_id and version_id contain unicode characters
    dataset_id = "ds_测试"
    version_id = "版本_αβγ"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.19μs -> 1.67μs (31.6% faster)

def test_edge_none_dataset_id():
    # Edge case: dataset_id is None (should raise TypeError)
    with pytest.raises(TypeError):
        construct_model_type_cache_path(None, "v1") # 5.49μs -> 5.67μs (3.28% slower)


def test_edge_version_id_false():
    # Edge case: version_id is False (should be treated as None)
    dataset_id = "ds200"
    version_id = False
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "", "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.39μs -> 1.79μs (33.7% faster)

def test_edge_version_id_zero():
    # Edge case: version_id is 0 (should convert to string "0")
    dataset_id = "ds300"
    version_id = 0
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "0", "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.33μs -> 1.58μs (47.7% faster)



def test_large_scale_many_ids():
    # Large scale: many different dataset_ids and version_ids
    for i in range(100):  # Keep under 1000 for performance
        dataset_id = f"ds{i:03d}"
        version_id = f"v{i:03d}"
        expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
        codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 120μs -> 94.4μs (28.0% faster)

def test_large_scale_long_strings():
    # Large scale: very long dataset_id and version_id strings
    dataset_id = "ds_" + "A" * 500
    version_id = "v_" + "B" * 400
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.48μs -> 1.87μs (32.7% faster)

def test_large_scale_many_empty_versions():
    # Large scale: many dataset_ids with empty version_id
    for i in range(100):
        dataset_id = f"ds{i:03d}"
        version_id = ""
        expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "", "model_type.json")
        codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 113μs -> 77.4μs (47.0% faster)


def test_large_scale_special_characters():
    # Large scale: dataset_id and version_id with special characters
    chars = "!@#$%^&*()_+-=[]{}|;:',.<>/?`~"
    for i in range(10):
        dataset_id = chars * (i + 1)
        version_id = chars[::-1] * (i + 1)
        expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
        codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 14.6μs -> 11.3μs (29.3% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os

# imports
import pytest
from inference.core.registries.roboflow import construct_model_type_cache_path

# function to test
# Simulate the environment variable for MODEL_CACHE_DIR
MODEL_CACHE_DIR = "/tmp/model_cache"
from inference.core.registries.roboflow import construct_model_type_cache_path

# ----------------------------- #
#           UNIT TESTS          #
# ----------------------------- #

# 1. Basic Test Cases

def test_basic_with_version():
    """Test with typical dataset_id and version_id."""
    dataset_id = "dataset123"
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.21μs -> 1.78μs (23.9% faster)

def test_basic_without_version():
    """Test with typical dataset_id and version_id=None."""
    dataset_id = "dataset123"
    version_id = None
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.17μs -> 1.41μs (54.4% faster)

def test_basic_with_empty_version():
    """Test with typical dataset_id and version_id='' (empty string)."""
    dataset_id = "dataset123"
    version_id = ""
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.20μs -> 1.44μs (53.0% faster)

def test_basic_with_numeric_ids():
    """Test with numeric dataset_id and version_id (as strings)."""
    dataset_id = "123"
    version_id = "456"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.08μs -> 1.65μs (26.1% faster)

# 2. Edge Test Cases

def test_edge_dataset_id_empty():
    """Test with empty dataset_id (should still build path)."""
    dataset_id = ""
    version_id = "v2"
    expected = os.path.join(MODEL_CACHE_DIR, "", version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.02μs -> 1.50μs (34.9% faster)

def test_edge_dataset_id_none():
    """Test with dataset_id=None (should raise TypeError)."""
    with pytest.raises(TypeError):
        construct_model_type_cache_path(None, "v2") # 5.57μs -> 5.75μs (3.05% slower)

def test_edge_version_id_special_chars():
    """Test with special characters in version_id."""
    dataset_id = "ds"
    version_id = "v$#@!_1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.25μs -> 1.69μs (33.4% faster)

def test_edge_dataset_id_special_chars():
    """Test with special characters in dataset_id."""
    dataset_id = "ds#@! 123"
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.06μs -> 1.55μs (33.4% faster)

def test_edge_version_id_slash():
    """Test with a slash in version_id (should not collapse path)."""
    dataset_id = "ds"
    version_id = "v1/2"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.03μs -> 1.58μs (28.7% faster)

def test_edge_dataset_id_slash():
    """Test with a slash in dataset_id (should not collapse path)."""
    dataset_id = "ds/abc"
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.02μs -> 1.50μs (34.4% faster)

def test_edge_both_empty():
    """Test with both dataset_id and version_id empty."""
    dataset_id = ""
    version_id = ""
    expected = os.path.join(MODEL_CACHE_DIR, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.14μs -> 1.63μs (31.1% faster)

def test_edge_version_id_none_and_empty_dataset_id():
    """Test with version_id None and dataset_id empty string."""
    dataset_id = ""
    version_id = None
    expected = os.path.join(MODEL_CACHE_DIR, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.04μs -> 1.60μs (27.6% faster)

def test_edge_dataset_id_long():
    """Test with a very long dataset_id (255 chars)."""
    dataset_id = "a" * 255
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.06μs -> 1.57μs (31.0% faster)

def test_edge_version_id_long():
    """Test with a very long version_id (255 chars)."""
    dataset_id = "ds"
    version_id = "b" * 255
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.02μs -> 1.60μs (26.8% faster)

def test_edge_dataset_id_whitespace():
    """Test with whitespace in dataset_id."""
    dataset_id = "   "
    version_id = "v1"
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 1.99μs -> 1.55μs (28.0% faster)

def test_edge_version_id_whitespace():
    """Test with whitespace in version_id."""
    dataset_id = "ds"
    version_id = "   "
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.06μs -> 1.57μs (31.4% faster)

# 3. Large Scale Test Cases

def test_large_scale_many_unique_paths():
    """Test generating many unique paths to check for scalability and collisions."""
    dataset_ids = [f"ds_{i}" for i in range(1000)]
    version_ids = [f"v_{i}" for i in range(1000)]
    paths = set()
    for d, v in zip(dataset_ids, version_ids):
        codeflash_output = construct_model_type_cache_path(d, v); path = codeflash_output # 1.17ms -> 901μs (29.3% faster)
        paths.add(path)

def test_large_scale_long_ids():
    """Test with very long dataset_id and version_id for scalability."""
    dataset_id = "d" * 500
    version_id = "v" * 500
    expected = os.path.join(MODEL_CACHE_DIR, dataset_id, version_id, "model_type.json")
    codeflash_output = construct_model_type_cache_path(dataset_id, version_id); result = codeflash_output # 2.67μs -> 1.93μs (38.0% faster)

def test_large_scale_empty_version_ids():
    """Test many dataset_ids with version_id=None."""
    dataset_ids = [f"ds_{i}" for i in range(500)]
    for d in dataset_ids:
        codeflash_output = construct_model_type_cache_path(d, None); path = codeflash_output # 566μs -> 382μs (48.4% faster)
        expected = os.path.join(MODEL_CACHE_DIR, d, "model_type.json")

def test_large_scale_empty_dataset_ids():
    """Test many version_ids with dataset_id=''."""
    version_ids = [f"v_{i}" for i in range(500)]
    for v in version_ids:
        codeflash_output = construct_model_type_cache_path("", v); path = codeflash_output # 560μs -> 429μs (30.6% faster)
        expected = os.path.join(MODEL_CACHE_DIR, v, "model_type.json")

def test_large_scale_collision_check():
    """Ensure that different (dataset_id, version_id) pairs never produce the same path."""
    pairs = [(f"ds_{i}", f"v_{i}") for i in range(500)]
    paths = set()
    for d, v in pairs:
        codeflash_output = construct_model_type_cache_path(d, v); path = codeflash_output # 585μs -> 453μs (29.2% faster)
        paths.add(path)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testsinferenceunit_testscoreutilstest_preprocess_py_testsinferenceunit_testscoreactive_learni__replay_test_0.py::test_inference_core_registries_roboflow_construct_model_type_cache_path	6.17μs	5.61μs	9.99%✅

To edit these changes git checkout codeflash/optimize-construct_model_type_cache_path-mhbzre26 and push.