⚡️ Speed up method IndexHostStore._key by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for IndexHostStore._key in pinecone/db_control/index_host_store.py

⏱️ Runtime : 589 microseconds → 538 microseconds (best of 278 runs)

📝 Explanation and details

The optimization replaces ":".join([config.api_key, index_name]) with config.api_key + ":" + index_name, achieving a 9% speedup by eliminating the overhead of Python's str.join() method.

Key optimization:

• Direct string concatenation (+) is faster than str.join() for small, fixed numbers of strings (2-3 items)
• Eliminates list creation - the original code creates a temporary list [config.api_key, index_name] that gets immediately consumed
• Reduces method call overhead - avoids the join() method dispatch and internal iteration

Why this works:
For small string concatenations, Python's + operator is optimized at the C level and doesn't suffer from the quadratic behavior that affects concatenating many strings in a loop. The join() method has additional overhead for handling arbitrary iterables and checking separator placement.

Performance characteristics from tests:

• Best gains on edge cases with empty strings (24-30% faster) - less work for the string concatenation
• Consistent improvements across normal cases (2-12% faster)
• Slight regression on very long strings (1000+ chars) where join's optimizations become beneficial
• Much faster error handling (33-66% improvement) when type errors occur, as the + operator fails faster than join's iteration

This optimization is most effective for typical API key/index name combinations of moderate length, which represents the common use case for this caching key generation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from pinecone.db_control.index_host_store import IndexHostStore


# function to test
class Config:
    def __init__(self, api_key):
        self.api_key = api_key

class SingletonMeta(type):
    _instances = {}
    def __call__(cls, *args, **kwargs):
        if cls not in cls._instances:
            cls._instances[cls] = super(SingletonMeta, cls).__call__(*args, **kwargs)
        return cls._instances[cls]
from pinecone.db_control.index_host_store import IndexHostStore

# unit tests

# 1. Basic Test Cases

def test_key_basic_normal_case():
    # Normal case with typical api_key and index_name
    config = Config("myapikey")
    store = IndexHostStore()
    codeflash_output = store._key(config, "myindex"); result = codeflash_output # 729ns -> 711ns (2.53% faster)

def test_key_basic_numeric_api_key_and_index():
    # Numeric api_key and index_name (as strings)
    config = Config("12345")
    store = IndexHostStore()
    codeflash_output = store._key(config, "67890"); result = codeflash_output # 615ns -> 563ns (9.24% faster)

def test_key_basic_special_characters():
    # api_key and index_name with special characters
    config = Config("api:key!@#")
    store = IndexHostStore()
    codeflash_output = store._key(config, "index/name$%^"); result = codeflash_output # 578ns -> 562ns (2.85% faster)

def test_key_basic_empty_index_name():
    # api_key normal, index_name empty string
    config = Config("key")
    store = IndexHostStore()
    codeflash_output = store._key(config, ""); result = codeflash_output # 542ns -> 490ns (10.6% faster)

def test_key_basic_empty_api_key():
    # api_key empty, index_name normal
    config = Config("")
    store = IndexHostStore()
    codeflash_output = store._key(config, "index"); result = codeflash_output # 548ns -> 428ns (28.0% faster)

def test_key_basic_both_empty():
    # Both api_key and index_name are empty
    config = Config("")
    store = IndexHostStore()
    codeflash_output = store._key(config, ""); result = codeflash_output # 569ns -> 439ns (29.6% faster)

# 2. Edge Test Cases

def test_key_edge_colon_in_api_key():
    # api_key contains colon
    config = Config("key:with:colon")
    store = IndexHostStore()
    codeflash_output = store._key(config, "index"); result = codeflash_output # 597ns -> 577ns (3.47% faster)

def test_key_edge_colon_in_index_name():
    # index_name contains colon
    config = Config("key")
    store = IndexHostStore()
    codeflash_output = store._key(config, "index:with:colon"); result = codeflash_output # 611ns -> 582ns (4.98% faster)

def test_key_edge_colon_in_both():
    # Both api_key and index_name contain colons
    config = Config("a:b")
    store = IndexHostStore()
    codeflash_output = store._key(config, "c:d:e"); result = codeflash_output # 582ns -> 553ns (5.24% faster)

def test_key_edge_unicode_characters():
    # Unicode in api_key and index_name
    config = Config("ключ")
    store = IndexHostStore()
    codeflash_output = store._key(config, "индекс"); result = codeflash_output # 827ns -> 807ns (2.48% faster)

def test_key_edge_whitespace():
    # api_key and index_name with leading/trailing/inner whitespace
    config = Config("  key  ")
    store = IndexHostStore()
    codeflash_output = store._key(config, "  index name "); result = codeflash_output # 577ns -> 547ns (5.48% faster)

def test_key_edge_long_strings():
    # Very long api_key and index_name (edge of reasonable length)
    api_key = "a" * 500
    index_name = "b" * 500
    config = Config(api_key)
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 795ns -> 873ns (8.93% slower)

def test_key_edge_nonstring_api_key():
    # api_key is not a string (simulate by passing int)
    config = Config(12345)
    store = IndexHostStore()
    # Should raise TypeError since join expects str
    with pytest.raises(TypeError):
        store._key(config, "index") # 2.26μs -> 1.36μs (66.4% faster)

def test_key_edge_nonstring_index_name():
    # index_name is not a string (simulate by passing int)
    config = Config("key")
    store = IndexHostStore()
    with pytest.raises(TypeError):
        store._key(config, 67890) # 2.01μs -> 1.35μs (49.1% faster)

def test_key_edge_config_missing_api_key():
    # config object without api_key attribute
    class DummyConfig:
        pass
    config = DummyConfig()
    store = IndexHostStore()
    with pytest.raises(AttributeError):
        store._key(config, "index") # 1.26μs -> 1.15μs (9.55% faster)

# 3. Large Scale Test Cases

def test_key_large_scale_many_unique_keys():
    # Create many unique keys and ensure all are unique
    store = IndexHostStore()
    keys = set()
    for i in range(1000):
        config = Config(f"key{i}")
        index_name = f"index{i}"
        codeflash_output = store._key(config, index_name); k = codeflash_output # 186μs -> 166μs (11.7% faster)
        keys.add(k)

def test_key_large_scale_longest_possible_strings():
    # Test with maximum allowed string length (Python str can be very large, use 1000 for test)
    api_key = "a" * 1000
    index_name = "b" * 1000
    config = Config(api_key)
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 830ns -> 918ns (9.59% slower)

def test_key_large_scale_performance():
    # Test that generating many keys is reasonably fast (no assertion, but should not hang)
    store = IndexHostStore()
    for i in range(1000):
        config = Config(f"api_key_{i}")
        index_name = f"index_{i}"
        codeflash_output = store._key(config, index_name); result = codeflash_output # 185μs -> 171μs (8.44% faster)

# Additional: Test that _key is deterministic (same input, same output)
def test_key_deterministic():
    config = Config("samekey")
    store = IndexHostStore()
    codeflash_output = store._key(config, "sameindex"); k1 = codeflash_output # 511ns -> 526ns (2.85% slower)
    codeflash_output = store._key(config, "sameindex"); k2 = codeflash_output # 227ns -> 210ns (8.10% 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 pinecone.db_control.index_host_store import IndexHostStore


# function to test
class Config:
    def __init__(self, api_key):
        self.api_key = api_key
from pinecone.db_control.index_host_store import IndexHostStore

# unit tests

# 1. Basic Test Cases

def test_key_basic_alphanumeric():
    # Test with typical alphanumeric api_key and index_name
    config = Config("abc123")
    index_name = "myindex"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 527ns -> 538ns (2.04% slower)

def test_key_basic_with_special_chars():
    # Test with api_key and index_name containing special characters
    config = Config("key!@#")
    index_name = "index$%^"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 555ns -> 569ns (2.46% slower)

def test_key_basic_numeric():
    # Test with numeric api_key and index_name
    config = Config("123456")
    index_name = "7890"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 563ns -> 535ns (5.23% faster)

def test_key_basic_empty_index_name():
    # Test with empty index_name
    config = Config("api_key")
    index_name = ""
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 526ns -> 480ns (9.58% faster)

def test_key_basic_empty_api_key():
    # Test with empty api_key
    config = Config("")
    index_name = "index"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 551ns -> 441ns (24.9% faster)

def test_key_basic_both_empty():
    # Test with both api_key and index_name empty
    config = Config("")
    index_name = ""
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 544ns -> 439ns (23.9% faster)

# 2. Edge Test Cases

def test_key_edge_colon_in_api_key():
    # Test with colon in api_key
    config = Config("api:key")
    index_name = "index"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 571ns -> 518ns (10.2% faster)

def test_key_edge_colon_in_index_name():
    # Test with colon in index_name
    config = Config("apikey")
    index_name = "in:dex"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 528ns -> 519ns (1.73% faster)

def test_key_edge_whitespace_in_api_key():
    # Test with whitespace in api_key
    config = Config("api key")
    index_name = "index"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 565ns -> 506ns (11.7% faster)

def test_key_edge_whitespace_in_index_name():
    # Test with whitespace in index_name
    config = Config("apikey")
    index_name = "in dex"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 584ns -> 501ns (16.6% faster)

def test_key_edge_unicode_characters():
    # Test with unicode characters in both api_key and index_name
    config = Config("ключ")
    index_name = "индекс"
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 826ns -> 840ns (1.67% slower)

def test_key_edge_long_strings():
    # Test with very long api_key and index_name
    api_key = "a" * 500
    index_name = "b" * 500
    config = Config(api_key)
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 787ns -> 790ns (0.380% slower)

def test_key_edge_none_api_key():
    # Test with None as api_key (should raise AttributeError)
    config = Config(None)
    index_name = "index"
    store = IndexHostStore()
    with pytest.raises(TypeError):
        store._key(config, index_name) # 2.25μs -> 1.46μs (54.2% faster)

def test_key_edge_none_index_name():
    # Test with None as index_name (should raise TypeError)
    config = Config("apikey")
    index_name = None
    store = IndexHostStore()
    with pytest.raises(TypeError):
        store._key(config, index_name) # 1.90μs -> 1.28μs (47.7% faster)

def test_key_edge_non_string_types():
    # Test with non-string types for api_key and index_name
    config = Config(12345)
    index_name = 67890
    store = IndexHostStore()
    # Should coerce to string via str() in join, but join expects strings
    with pytest.raises(TypeError):
        store._key(config, index_name) # 1.86μs -> 1.39μs (33.9% faster)

# 3. Large Scale Test Cases

def test_key_large_scale_many_unique_keys():
    # Test with many unique api_keys and index_names to ensure no collisions
    store = IndexHostStore()
    keys = set()
    for i in range(1000):
        config = Config(f"api_{i}")
        index_name = f"index_{i}"
        codeflash_output = store._key(config, index_name); key = codeflash_output # 188μs -> 175μs (7.19% faster)
        keys.add(key)

def test_key_large_scale_long_strings():
    # Test joining of very long strings
    api_key = "x" * 999
    index_name = "y" * 999
    config = Config(api_key)
    store = IndexHostStore()
    codeflash_output = store._key(config, index_name); result = codeflash_output # 746ns -> 906ns (17.7% slower)

def test_key_large_scale_repeated_calls():
    # Test performance and determinism with repeated calls
    config = Config("repeatkey")
    index_name = "repeatindex"
    store = IndexHostStore()
    results = [store._key(config, index_name) for _ in range(1000)] # 503ns -> 546ns (7.88% slower)


#------------------------------------------------
from pinecone.config.config import Config
from pinecone.db_control.index_host_store import IndexHostStore

def test_IndexHostStore__key():
    IndexHostStore._key(IndexHostStore(), Config(api_key='', host='', proxy_url='', proxy_headers={}, ssl_ca_certs='', ssl_verify=True, additional_headers={}, source_tag=''), '')

To edit these changes git checkout codeflash/optimize-IndexHostStore._key-mh6hmgay and push.