⚡️ Speed up function to_proto_update_metadata by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for to_proto_update_metadata in chromadb/proto/convert.py

⏱️ Runtime : 5.39 milliseconds → 5.10 milliseconds (best of 267 runs)

📝 Explanation and details

The optimization replaces isinstance() checks with direct type() identity comparisons using the is operator. Instead of isinstance(value, bool), the code uses t = type(value) followed by t is bool.

Why this is faster:

• isinstance() performs inheritance hierarchy traversal to check if a value is an instance of a type or its subclasses
• type() is T performs a simple identity comparison between type objects, which is much faster
• Since the function only handles primitive types (str, int, float, bool, None) that are rarely subclassed in practice, the behavioral change is negligible

Performance impact:
The line profiler shows the type checking operations (isinstance calls) took significant time in the original version - around 19.6% and 19.3% of total function time for the first two checks. The optimized version reduces this overhead by using faster type identity checks.

Test case effectiveness:
The optimization shows consistent gains across test cases:

• Large-scale tests see the biggest improvements (5-12% faster) because they perform many type checks
• Mixed-type dictionaries benefit significantly (6.19% faster for 1000+ mixed items)
• Single-value tests show smaller but consistent gains, especially for int/float values
• Error handling for invalid types is 8-12% faster due to quicker type rejection

The 5% overall speedup comes from reducing the per-value type dispatch overhead, which is especially valuable when processing metadata dictionaries with many entries.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Dict, Union

# imports
import pytest  # used for our unit tests
from chromadb.proto.convert import to_proto_update_metadata


class UpdateMetadataValue:
    def __init__(self, string_value=None, int_value=None, float_value=None, bool_value=None):
        self.string_value = string_value
        self.int_value = int_value
        self.float_value = float_value
        self.bool_value = bool_value

    def __eq__(self, other):
        if not isinstance(other, UpdateMetadataValue):
            return False
        return (self.string_value == other.string_value and
                self.int_value == other.int_value and
                self.float_value == other.float_value and
                self.bool_value == other.bool_value)

    def __repr__(self):
        return (f"UpdateMetadataValue(string_value={self.string_value!r}, "
                f"int_value={self.int_value!r}, float_value={self.float_value!r}, "
                f"bool_value={self.bool_value!r})")

class UpdateMetadata:
    def __init__(self, metadata: Dict[str, UpdateMetadataValue]):
        self.metadata = metadata

    def __eq__(self, other):
        if not isinstance(other, UpdateMetadata):
            return False
        return self.metadata == other.metadata

    def __repr__(self):
        return f"UpdateMetadata(metadata={self.metadata!r})"

# Typing for UpdateMetadata input
UpdateMetadataDict = Dict[str, Union[str, int, float, bool, None]]
from chromadb.proto.convert import to_proto_update_metadata

# unit tests

# --- Basic Test Cases ---

def test_basic_string():
    """Test conversion of a single string value."""
    input_meta = {"name": "Alice"}
    expected = UpdateMetadata({"name": UpdateMetadataValue(string_value="Alice")})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 6.43μs -> 6.52μs (1.32% slower)

def test_basic_int():
    """Test conversion of a single int value."""
    input_meta = {"age": 30}
    expected = UpdateMetadata({"age": UpdateMetadataValue(int_value=30)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.80μs -> 5.77μs (0.416% faster)

def test_basic_float():
    """Test conversion of a single float value."""
    input_meta = {"height": 1.75}
    expected = UpdateMetadata({"height": UpdateMetadataValue(float_value=1.75)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 6.15μs -> 6.26μs (1.79% slower)

def test_basic_bool_true():
    """Test conversion of a single bool True value."""
    input_meta = {"is_admin": True}
    expected = UpdateMetadata({"is_admin": UpdateMetadataValue(bool_value=True)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.78μs -> 6.07μs (4.83% slower)

def test_basic_bool_false():
    """Test conversion of a single bool False value."""
    input_meta = {"is_admin": False}
    expected = UpdateMetadata({"is_admin": UpdateMetadataValue(bool_value=False)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.65μs -> 5.73μs (1.40% slower)

def test_basic_none():
    """Test conversion of a single None value (deletion)."""
    input_meta = {"nickname": None}
    expected = UpdateMetadata({"nickname": UpdateMetadataValue()})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 4.97μs -> 5.05μs (1.50% slower)

def test_basic_multiple_types():
    """Test conversion of multiple types in one dict."""
    input_meta = {
        "name": "Bob",
        "age": 42,
        "height": 1.80,
        "is_admin": True,
        "nickname": None
    }
    expected = UpdateMetadata({
        "name": UpdateMetadataValue(string_value="Bob"),
        "age": UpdateMetadataValue(int_value=42),
        "height": UpdateMetadataValue(float_value=1.80),
        "is_admin": UpdateMetadataValue(bool_value=True),
        "nickname": UpdateMetadataValue()
    })
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 10.7μs -> 10.9μs (1.14% slower)

# --- Edge Test Cases ---

def test_empty_dict():
    """Test conversion of an empty dict."""
    input_meta = {}
    expected = UpdateMetadata({})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 2.47μs -> 2.59μs (4.82% slower)

def test_key_with_empty_string():
    """Test conversion where value is an empty string."""
    input_meta = {"empty": ""}
    expected = UpdateMetadata({"empty": UpdateMetadataValue(string_value="")})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.63μs -> 5.62μs (0.124% faster)

def test_key_with_zero_int():
    """Test conversion where value is zero integer."""
    input_meta = {"zero": 0}
    expected = UpdateMetadata({"zero": UpdateMetadataValue(int_value=0)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.57μs -> 5.39μs (3.40% faster)

def test_key_with_zero_float():
    """Test conversion where value is zero float."""
    input_meta = {"zero": 0.0}
    expected = UpdateMetadata({"zero": UpdateMetadataValue(float_value=0.0)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 6.20μs -> 6.13μs (1.17% faster)

def test_key_with_false_bool():
    """Test conversion where value is False."""
    input_meta = {"flag": False}
    expected = UpdateMetadata({"flag": UpdateMetadataValue(bool_value=False)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.70μs -> 5.75μs (0.818% slower)

def test_key_with_true_bool():
    """Test conversion where value is True."""
    input_meta = {"flag": True}
    expected = UpdateMetadata({"flag": UpdateMetadataValue(bool_value=True)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.66μs -> 5.69μs (0.510% slower)

def test_key_with_none():
    """Test conversion where value is None."""
    input_meta = {"delete_me": None}
    expected = UpdateMetadata({"delete_me": UpdateMetadataValue()})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.21μs -> 5.08μs (2.64% faster)

def test_key_with_special_characters():
    """Test conversion where key has special characters."""
    input_meta = {"na!@#me": "special"}
    expected = UpdateMetadata({"na!@#me": UpdateMetadataValue(string_value="special")})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.31μs -> 5.20μs (2.02% faster)

def test_key_with_long_string():
    """Test conversion where value is a long string."""
    long_str = "a" * 256
    input_meta = {"long": long_str}
    expected = UpdateMetadata({"long": UpdateMetadataValue(string_value=long_str)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.38μs -> 5.43μs (0.939% slower)

def test_key_with_large_int():
    """Test conversion where value is a large int."""
    large_int = 2**62
    input_meta = {"bigint": large_int}
    expected = UpdateMetadata({"bigint": UpdateMetadataValue(int_value=large_int)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.53μs -> 5.61μs (1.39% slower)

def test_key_with_large_float():
    """Test conversion where value is a large float."""
    large_float = 1.7e308
    input_meta = {"bigfloat": large_float}
    expected = UpdateMetadata({"bigfloat": UpdateMetadataValue(float_value=large_float)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 6.24μs -> 5.99μs (4.16% faster)

def test_key_with_nan_float():
    """Test conversion where value is NaN float."""
    import math
    input_meta = {"nan": float('nan')}
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.95μs -> 5.97μs (0.402% slower)

def test_key_with_inf_float():
    """Test conversion where value is inf float."""
    import math
    input_meta = {"inf": float('inf')}
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.93μs -> 6.02μs (1.41% slower)

def test_key_with_negative_inf_float():
    """Test conversion where value is -inf float."""
    import math
    input_meta = {"ninf": float('-inf')}
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 5.93μs -> 5.92μs (0.051% faster)

def test_invalid_type_list():
    """Test conversion where value is a list (invalid type)."""
    input_meta = {"bad": [1, 2, 3]}
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_meta) # 2.91μs -> 2.84μs (2.43% faster)

def test_invalid_type_dict():
    """Test conversion where value is a dict (invalid type)."""
    input_meta = {"bad": {"a": 1}}
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_meta) # 2.77μs -> 2.70μs (2.52% faster)

def test_invalid_type_object():
    """Test conversion where value is an object (invalid type)."""
    class Dummy: pass
    input_meta = {"bad": Dummy()}
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_meta) # 2.79μs -> 2.54μs (9.94% faster)

def test_bool_vs_int_priority():
    """Test that bool values are not treated as int (priority check)."""
    input_meta = {"flag": True, "num": 1}
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 10.1μs -> 10.1μs (0.158% slower)

# --- Large Scale Test Cases ---

def test_large_dict_all_strings():
    """Test conversion of a large dict with all string values."""
    input_meta = {f"key_{i}": f"value_{i}" for i in range(1000)}
    expected = UpdateMetadata({f"key_{i}": UpdateMetadataValue(string_value=f"value_{i}") for i in range(1000)})
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 710μs -> 696μs (2.01% faster)

def test_large_dict_mixed_types():
    """Test conversion of a large dict with mixed types."""
    input_meta = {}
    expected_meta = {}
    for i in range(250):
        input_meta[f"str_{i}"] = f"value_{i}"
        expected_meta[f"str_{i}"] = UpdateMetadataValue(string_value=f"value_{i}")
        input_meta[f"int_{i}"] = i
        expected_meta[f"int_{i}"] = UpdateMetadataValue(int_value=i)
        input_meta[f"float_{i}"] = float(i) / 10.0
        expected_meta[f"float_{i}"] = UpdateMetadataValue(float_value=float(i) / 10.0)
        input_meta[f"bool_{i}"] = (i % 2 == 0)
        expected_meta[f"bool_{i}"] = UpdateMetadataValue(bool_value=(i % 2 == 0))
        input_meta[f"none_{i}"] = None
        expected_meta[f"none_{i}"] = UpdateMetadataValue()
    expected = UpdateMetadata(expected_meta)
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 976μs -> 919μs (6.19% faster)

def test_large_dict_with_edge_values():
    """Test conversion of a large dict with edge values (empty string, zero, None, etc)."""
    input_meta = {}
    expected_meta = {}
    for i in range(200):
        input_meta[f"emptystr_{i}"] = ""
        expected_meta[f"emptystr_{i}"] = UpdateMetadataValue(string_value="")
        input_meta[f"zero_{i}"] = 0
        expected_meta[f"zero_{i}"] = UpdateMetadataValue(int_value=0)
        input_meta[f"zerofloat_{i}"] = 0.0
        expected_meta[f"zerofloat_{i}"] = UpdateMetadataValue(float_value=0.0)
        input_meta[f"none_{i}"] = None
        expected_meta[f"none_{i}"] = UpdateMetadataValue()
    expected = UpdateMetadata(expected_meta)
    codeflash_output = to_proto_update_metadata(input_meta); result = codeflash_output # 593μs -> 558μs (6.18% faster)

def test_large_dict_invalid_types():
    """Test conversion of a large dict with one invalid type, should raise."""
    input_meta = {f"key_{i}": i for i in range(999)}
    input_meta["bad"] = [1, 2, 3]  # Add one invalid type
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_meta) # 366μs -> 327μs (12.1% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from typing import Dict, Optional, Union

# imports
import pytest  # used for our unit tests
from chromadb.proto.convert import to_proto_update_metadata


# Simulated proto classes
class UpdateMetadataValue:
    def __init__(
        self,
        string_value: Optional[str] = None,
        int_value: Optional[int] = None,
        float_value: Optional[float] = None,
        bool_value: Optional[bool] = None,
    ):
        self.string_value = string_value
        self.int_value = int_value
        self.float_value = float_value
        self.bool_value = bool_value

    def __eq__(self, other):
        if not isinstance(other, UpdateMetadataValue):
            return False
        return (
            self.string_value == other.string_value
            and self.int_value == other.int_value
            and self.float_value == other.float_value
            and self.bool_value == other.bool_value
        )

class UpdateMetadata:
    def __init__(self, metadata: Dict[str, UpdateMetadataValue]):
        self.metadata = metadata

    def __eq__(self, other):
        if not isinstance(other, UpdateMetadata):
            return False
        return self.metadata == other.metadata

# Patch chromadb.proto.chroma_pb2 for testing
class chroma_pb:
    UpdateMetadata = UpdateMetadata
    UpdateMetadataValue = UpdateMetadataValue
from chromadb.proto.convert import to_proto_update_metadata

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

# 1. Basic Test Cases

def test_basic_string_metadata():
    # Test with a single string key-value
    input_md = {'name': 'test'}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 7.85μs -> 7.81μs (0.538% faster)
    expected = chroma_pb.UpdateMetadata({'name': chroma_pb.UpdateMetadataValue(string_value='test')})

def test_basic_int_metadata():
    # Test with a single int key-value
    input_md = {'count': 42}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 6.15μs -> 6.41μs (4.01% slower)
    expected = chroma_pb.UpdateMetadata({'count': chroma_pb.UpdateMetadataValue(int_value=42)})

def test_basic_float_metadata():
    # Test with a single float key-value
    input_md = {'score': 3.14}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 6.47μs -> 6.41μs (0.811% faster)
    expected = chroma_pb.UpdateMetadata({'score': chroma_pb.UpdateMetadataValue(float_value=3.14)})

def test_basic_bool_metadata_true():
    # Test with a single bool key-value (True)
    input_md = {'active': True}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.95μs -> 6.01μs (1.11% slower)
    expected = chroma_pb.UpdateMetadata({'active': chroma_pb.UpdateMetadataValue(bool_value=True)})

def test_basic_bool_metadata_false():
    # Test with a single bool key-value (False)
    input_md = {'active': False}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.73μs -> 5.97μs (4.05% slower)
    expected = chroma_pb.UpdateMetadata({'active': chroma_pb.UpdateMetadataValue(bool_value=False)})

def test_basic_none_metadata():
    # Test with a single None key-value (should delete key)
    input_md = {'obsolete': None}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.28μs -> 5.25μs (0.572% faster)
    expected = chroma_pb.UpdateMetadata({'obsolete': chroma_pb.UpdateMetadataValue()})

def test_basic_multiple_types():
    # Test with multiple types in one dict
    input_md = {
        'name': 'test',
        'count': 1,
        'score': 2.5,
        'active': True,
        'obsolete': None,
    }
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 10.9μs -> 10.9μs (0.486% faster)
    expected = chroma_pb.UpdateMetadata({
        'name': chroma_pb.UpdateMetadataValue(string_value='test'),
        'count': chroma_pb.UpdateMetadataValue(int_value=1),
        'score': chroma_pb.UpdateMetadataValue(float_value=2.5),
        'active': chroma_pb.UpdateMetadataValue(bool_value=True),
        'obsolete': chroma_pb.UpdateMetadataValue(),
    })

# 2. Edge Test Cases

def test_empty_metadata():
    # Test with empty metadata dict
    input_md = {}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 2.56μs -> 2.58μs (0.930% slower)
    expected = chroma_pb.UpdateMetadata({})

def test_metadata_with_empty_string():
    # Test with empty string value
    input_md = {'desc': ''}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.63μs -> 5.63μs (0.124% faster)
    expected = chroma_pb.UpdateMetadata({'desc': chroma_pb.UpdateMetadataValue(string_value='')})

def test_metadata_with_zero_int():
    # Test with zero int value
    input_md = {'zero': 0}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.51μs -> 5.43μs (1.57% faster)
    expected = chroma_pb.UpdateMetadata({'zero': chroma_pb.UpdateMetadataValue(int_value=0)})

def test_metadata_with_zero_float():
    # Test with zero float value
    input_md = {'zero': 0.0}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 6.16μs -> 6.02μs (2.34% faster)
    expected = chroma_pb.UpdateMetadata({'zero': chroma_pb.UpdateMetadataValue(float_value=0.0)})

def test_metadata_with_false_bool():
    # Test with False bool value
    input_md = {'flag': False}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.65μs -> 5.68μs (0.564% slower)
    expected = chroma_pb.UpdateMetadata({'flag': chroma_pb.UpdateMetadataValue(bool_value=False)})

def test_metadata_with_large_int():
    # Test with a very large integer
    input_md = {'bigint': 2**62}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.46μs -> 5.36μs (1.79% faster)
    expected = chroma_pb.UpdateMetadata({'bigint': chroma_pb.UpdateMetadataValue(int_value=2**62)})

def test_metadata_with_negative_int():
    # Test with negative integer
    input_md = {'neg': -123}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.45μs -> 5.39μs (1.06% faster)
    expected = chroma_pb.UpdateMetadata({'neg': chroma_pb.UpdateMetadataValue(int_value=-123)})

def test_metadata_with_negative_float():
    # Test with negative float
    input_md = {'neg': -3.14}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 5.86μs -> 5.89μs (0.679% slower)
    expected = chroma_pb.UpdateMetadata({'neg': chroma_pb.UpdateMetadataValue(float_value=-3.14)})

def test_metadata_with_special_float_values():
    # Test with float('inf'), float('-inf'), float('nan')
    import math
    input_md = {
        'inf': float('inf'),
        'ninf': float('-inf'),
        'nan': float('nan')
    }
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 8.65μs -> 8.37μs (3.41% faster)

def test_metadata_with_non_str_key():
    # Test with non-string keys (should fail, as only string keys are expected)
    input_md = {123: 'value'}
    with pytest.raises(TypeError):
        # dict comprehension in to_proto_update_metadata will not fail, but
        # downstream code may expect str keys. We enforce str keys here.
        for k in input_md.keys():
            pass
        to_proto_update_metadata(input_md) # 4.77μs -> 4.71μs (1.27% faster)

def test_metadata_with_unsupported_value_type():
    # Test with unsupported value type (e.g., list, dict)
    input_md = {'bad': [1, 2, 3]}
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_md) # 2.99μs -> 2.76μs (8.44% faster)
    input_md2 = {'bad': {'a': 1}}
    with pytest.raises(ValueError):
        to_proto_update_metadata(input_md2) # 1.67μs -> 1.53μs (8.82% faster)

# 3. Large Scale Test Cases

def test_large_metadata_dict():
    # Test with large metadata dict (1000 items)
    input_md = {f'key{i}': i for i in range(1000)}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 691μs -> 656μs (5.46% faster)

def test_large_metadata_mixed_types():
    # Test with large metadata dict with mixed types
    input_md = {}
    for i in range(250):
        input_md[f'str{i}'] = f'val{i}'
        input_md[f'int{i}'] = i
        input_md[f'float{i}'] = float(i)
        input_md[f'bool{i}'] = bool(i % 2)
    # Add some None values
    for i in range(50):
        input_md[f'none{i}'] = None
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 792μs -> 753μs (5.11% faster)

def test_large_metadata_all_none():
    # Test with large metadata dict where all values are None
    input_md = {f'key{i}': None for i in range(500)}
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 319μs -> 290μs (9.89% faster)
    for v in result.metadata.values():
        pass

def test_performance_large_scale():
    # Performance test: ensure function completes quickly for large input
    import time
    input_md = {f'key{i}': i for i in range(1000)}
    start = time.time()
    codeflash_output = to_proto_update_metadata(input_md); result = codeflash_output # 686μs -> 648μs (5.84% faster)
    end = time.time()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from chromadb.proto.convert import to_proto_update_metadata

def test_to_proto_update_metadata():
    to_proto_update_metadata({})

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_p_g0hne0/tmpigiztirp/test_concolic_coverage.py::test_to_proto_update_metadata	3.53μs	3.45μs	2.14%✅

To edit these changes git checkout codeflash/optimize-to_proto_update_metadata-mh7quque and push.