⚡️ Speed up function get_api_version by 21%

[codeflash-ai]

📄 21% (0.21x) speedup for get_api_version in src/cohere/aws_client.py

⏱️ Runtime : 1.38 milliseconds → 1.14 milliseconds (best of 185 runs)

📝 Explanation and details

The optimization moves the dictionary int_version from being created inside the function to a module-level constant _INT_VERSION. This eliminates the repeated dictionary creation overhead that was consuming ~68% of the original function's runtime (lines creating the dictionary took 27% + 19.9% + 21.3% = 68.2% of total time).

Key changes:

• Dictionary is now created once at module import time instead of on every function call
• Function body reduced from 4 operations to 1 dictionary lookup

Why this leads to speedup:

• Dictionary creation in Python involves memory allocation and hash table initialization
• The profiler shows 6,143 function calls were creating identical dictionaries repeatedly
• Moving to module scope eliminates this redundant work, keeping only the fast dictionary lookup operation

Performance characteristics:

• Consistent ~20-44% speedup across all test cases
• Larger improvements for simple cases (empty strings: 63.6% faster)
• Even large-scale tests with 500-1000 calls show 18-25% improvements
• Benefits scale linearly with call frequency since dictionary creation overhead is completely eliminated

This is a classic example of hoisting invariant computations out of frequently-called functions.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from cohere.aws_client import get_api_version

# unit tests

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

def test_get_api_version_v1():
    # Basic: Standard input "v1" should return 1
    codeflash_output = get_api_version(version="v1") # 825ns -> 606ns (36.1% faster)

def test_get_api_version_v2():
    # Basic: Standard input "v2" should return 2
    codeflash_output = get_api_version(version="v2") # 628ns -> 513ns (22.4% faster)

def test_get_api_version_default():
    # Basic: Unrecognized version should default to 1
    codeflash_output = get_api_version(version="v3") # 629ns -> 470ns (33.8% faster)
    codeflash_output = get_api_version(version="foo") # 354ns -> 259ns (36.7% faster)
    codeflash_output = get_api_version(version="") # 288ns -> 176ns (63.6% faster)

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

def test_get_api_version_case_sensitivity():
    # Edge: Case sensitivity - should default to 1 if not exact match
    codeflash_output = get_api_version(version="V1") # 609ns -> 422ns (44.3% faster)
    codeflash_output = get_api_version(version="V2") # 371ns -> 268ns (38.4% faster)
    codeflash_output = get_api_version(version="v1 ") # 227ns -> 219ns (3.65% faster)
    codeflash_output = get_api_version(version=" v1") # 215ns -> 187ns (15.0% faster)


def test_get_api_version_numeric_string():
    # Edge: Numeric string should default to 1
    codeflash_output = get_api_version(version="1") # 982ns -> 780ns (25.9% faster)
    codeflash_output = get_api_version(version="2") # 295ns -> 222ns (32.9% faster)


def test_get_api_version_missing_argument():
    # Edge: Missing required keyword argument should raise TypeError
    with pytest.raises(TypeError):
        get_api_version() # 2.23μs -> 2.19μs (1.60% faster)


def test_get_api_version_long_string():
    # Edge: Very long string should default to 1
    long_str = "v1" * 100
    codeflash_output = get_api_version(version=long_str) # 920ns -> 761ns (20.9% faster)

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

def test_get_api_version_many_unrecognized_versions():
    # Large Scale: Test 1000 different unrecognized versions, all should default to 1
    for i in range(1000):
        codeflash_output = get_api_version(version=f"unknown_version_{i}") # 229μs -> 193μs (18.6% faster)

def test_get_api_version_many_valid_and_invalid_versions():
    # Large Scale: Mix of valid and invalid versions
    versions = ["v1", "v2"] + [f"v{i}" for i in range(3, 1000)]
    expected = [1, 2] + [1] * (len(versions) - 2)
    for v, exp in zip(versions, expected):
        codeflash_output = get_api_version(version=v) # 225μs -> 189μs (18.9% faster)

def test_get_api_version_performance_large_batch():
    # Large Scale: Batch test for performance (not actual timing, just correctness)
    # Generate 1000 calls with alternating valid/invalid versions
    for i in range(1000):
        if i % 2 == 0:
            codeflash_output = get_api_version(version="v1")
        else:
            codeflash_output = get_api_version(version=f"invalid_{i}")

def test_get_api_version_all_possible_single_char_versions():
    # Large Scale: Test all single-character versions (printable ASCII)
    import string
    for c in string.printable:
        if c == "v":
            codeflash_output = get_api_version(version="v")
        else:
            codeflash_output = get_api_version(version=c)

# ----------- Mutation Detection Test -----------

def test_get_api_version_mutation_detection():
    # If the mapping changes, this test will fail
    codeflash_output = get_api_version(version="v1") # 647ns -> 450ns (43.8% faster)
    codeflash_output = get_api_version(version="v2") # 269ns -> 220ns (22.3% faster)
    # If default changes, this will fail
    codeflash_output = get_api_version(version="not_a_version") # 236ns -> 198ns (19.2% faster)
# 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 cohere.aws_client import get_api_version

# unit tests

# Basic Test Cases

def test_get_api_version_v1():
    # Test basic input 'v1'
    codeflash_output = get_api_version(version="v1") # 611ns -> 488ns (25.2% faster)

def test_get_api_version_v2():
    # Test basic input 'v2'
    codeflash_output = get_api_version(version="v2") # 608ns -> 490ns (24.1% faster)

def test_get_api_version_default():
    # Test default behavior for unknown version
    codeflash_output = get_api_version(version="v3") # 601ns -> 493ns (21.9% faster)
    codeflash_output = get_api_version(version="unknown") # 312ns -> 263ns (18.6% faster)
    codeflash_output = get_api_version(version="") # 260ns -> 181ns (43.6% faster)

# Edge Test Cases

def test_get_api_version_case_sensitivity():
    # 'V1' and 'V2' (uppercase) should not match
    codeflash_output = get_api_version(version="V1") # 589ns -> 431ns (36.7% faster)
    codeflash_output = get_api_version(version="V2") # 356ns -> 255ns (39.6% faster)

def test_get_api_version_leading_trailing_spaces():
    # Leading/trailing spaces should not match
    codeflash_output = get_api_version(version=" v1") # 537ns -> 415ns (29.4% faster)
    codeflash_output = get_api_version(version="v1 ") # 325ns -> 296ns (9.80% faster)
    codeflash_output = get_api_version(version=" v2 ") # 252ns -> 204ns (23.5% faster)

def test_get_api_version_numeric_string():
    # Numeric string should not match
    codeflash_output = get_api_version(version="1") # 585ns -> 428ns (36.7% faster)
    codeflash_output = get_api_version(version="2") # 341ns -> 236ns (44.5% faster)


def test_get_api_version_no_argument():
    # Omitting the required keyword argument should raise TypeError
    with pytest.raises(TypeError):
        get_api_version() # 2.22μs -> 2.15μs (3.02% faster)

def test_get_api_version_bool():
    # Passing a boolean should not match
    codeflash_output = get_api_version(version=True) # 907ns -> 739ns (22.7% faster)
    codeflash_output = get_api_version(version=False) # 322ns -> 258ns (24.8% faster)

def test_get_api_version_special_characters():
    # Special characters should not match
    codeflash_output = get_api_version(version="v1!") # 705ns -> 533ns (32.3% faster)
    codeflash_output = get_api_version(version="v2@") # 290ns -> 216ns (34.3% faster)

def test_get_api_version_long_string():
    # Long string should not match
    codeflash_output = get_api_version(version="v1v1v1v1v1") # 648ns -> 484ns (33.9% faster)

def test_get_api_version_partial_match():
    # Partial match should not match
    codeflash_output = get_api_version(version="v") # 601ns -> 430ns (39.8% faster)

def test_get_api_version_dict_input():
    # Passing a dict as version should raise TypeError
    with pytest.raises(TypeError):
        get_api_version(version={"v1": 1}) # 1.30μs -> 1.16μs (12.0% faster)

def test_get_api_version_list_input():
    # Passing a list as version should raise TypeError
    with pytest.raises(TypeError):
        get_api_version(version=["v1"]) # 1.30μs -> 1.14μs (13.5% faster)

# Large Scale Test Cases

def test_get_api_version_large_number_of_calls():
    # Test performance and determinism with many calls
    for i in range(500):
        # All should default to 1 for unknown versions
        codeflash_output = get_api_version(version=f"v{i}") # 112μs -> 93.8μs (19.9% faster)
    # Ensure known versions still work
    for _ in range(500):
        codeflash_output = get_api_version(version="v1") # 104μs -> 84.8μs (23.0% faster)
        codeflash_output = get_api_version(version="v2")

def test_get_api_version_large_string_input():
    # Test with very large string input
    large_str = "v1" * 200  # 600 characters
    codeflash_output = get_api_version(version=large_str) # 801ns -> 578ns (38.6% faster)

def test_get_api_version_stress_known_and_unknown():
    # Mix known and unknown versions in a large batch
    known_versions = ["v1", "v2"]
    unknown_versions = [f"v{i}" for i in range(3, 1003)]
    for v in known_versions:
        codeflash_output = get_api_version(version=v) # 926ns -> 711ns (30.2% faster)
    for v in unknown_versions:
        codeflash_output = get_api_version(version=v) # 225μs -> 187μs (20.1% faster)

def test_get_api_version_unicode_input():
    # Unicode string input should not match
    codeflash_output = get_api_version(version="v1😀") # 707ns -> 521ns (35.7% faster)
    codeflash_output = get_api_version(version="v2🚀") # 369ns -> 285ns (29.5% faster)

def test_get_api_version_empty_string_large_scale():
    # Many calls with empty string
    for _ in range(500):
        codeflash_output = get_api_version(version="") # 106μs -> 84.7μs (25.5% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from cohere.aws_client import get_api_version

def test_get_api_version():
    get_api_version(version='')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_xj4ciy1w/tmpw1q3isyv/test_concolic_coverage.py::test_get_api_version	577ns	409ns	41.1%✅

To edit these changes git checkout codeflash/optimize-get_api_version-mh1744vo and push.