⚡️ Speed up method _Reranker.jinaai by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for _Reranker.jinaai in weaviate/collections/classes/config.py

⏱️ Runtime : 775 microseconds → 734 microseconds (best of 29 runs)

📝 Explanation and details

The optimization introduces a fast path for the common default case where model=None by avoiding keyword argument initialization.

Key Changes:

• Added an explicit if model is None: check to return _RerankerJinaAIConfig() (no keyword arguments)
• Non-None models still use _RerankerJinaAIConfig(model=model) (keyword argument)

Why This Improves Performance:
In Python, constructor calls with keyword arguments have slightly more overhead than positional/default constructors due to argument parsing and dictionary lookups. The line profiler shows the optimization is most effective when model=None (the default case), where it eliminates the keyword argument overhead entirely.

Test Case Performance Patterns:

• Best gains (7-9% faster): Tests with model=None (default case) benefit most from the fast path
• Small losses (3-12% slower): Tests with non-None models have minimal overhead from the added if check
• Bulk operations (2-9% faster): Large-scale tests show net positive gains, suggesting the default case is common in practice

The 5% overall speedup indicates that None values are frequent enough to make the optimization worthwhile, despite the slight penalty for non-None cases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Literal, Optional, Union

# imports
import pytest
from weaviate.collections.classes.config import _Reranker

# --- Function to test (minimal implementation to match the interface and behavior) ---

RerankerJinaAIModel = Literal[
    "jina-reranker-v2-base-multilingual",
    "jina-reranker-v1-base-en",
    "jina-reranker-v1-turbo-en",
    "jina-reranker-v1-tiny-en",
    "jina-colbert-v1-en",
]

class _RerankerJinaAIConfig:
    # Simulate the config object returned by jinaai
    def __init__(self, model=None):
        self.model = model

    def __eq__(self, other):
        # For test assertions
        if not isinstance(other, _RerankerJinaAIConfig):
            return False
        return self.model == other.model

    def __repr__(self):
        return f"_RerankerJinaAIConfig(model={self.model!r})"
from weaviate.collections.classes.config import _Reranker

# --- Unit tests ---

# 1. Basic Test Cases

def test_jinaai_none_model():
    # Test default (model=None) returns config with model=None
    codeflash_output = _Reranker.jinaai(); result = codeflash_output # 9.08μs -> 8.41μs (8.03% faster)

def test_jinaai_valid_model_strings():
    # Test all valid model strings
    valid_models = [
        "jina-reranker-v2-base-multilingual",
        "jina-reranker-v1-base-en",
        "jina-reranker-v1-turbo-en",
        "jina-reranker-v1-tiny-en",
        "jina-colbert-v1-en",
    ]
    for m in valid_models:
        codeflash_output = _Reranker.jinaai(model=m); result = codeflash_output # 11.1μs -> 11.8μs (5.82% slower)

def test_jinaai_valid_model_literal():
    # Test passing a Literal value (should be same as str at runtime)
    m = "jina-reranker-v1-turbo-en"
    codeflash_output = _Reranker.jinaai(model=m); result = codeflash_output # 4.03μs -> 4.49μs (10.1% slower)

# 2. Edge Test Cases









def test_jinaai_none_explicit():
    # Test passing model=None explicitly returns config with model=None
    codeflash_output = _Reranker.jinaai(model=None); result = codeflash_output # 8.84μs -> 8.22μs (7.45% faster)

def test_jinaai_repr_and_eq():
    # Test __repr__ and __eq__ for config objects
    codeflash_output = _Reranker.jinaai(model="jina-colbert-v1-en"); a = codeflash_output # 5.64μs -> 6.23μs (9.49% slower)
    b = _RerankerJinaAIConfig(model="jina-colbert-v1-en")
    codeflash_output = _Reranker.jinaai(model="jina-reranker-v1-base-en"); c = codeflash_output # 1.59μs -> 1.65μs (3.53% slower)

# 3. Large Scale Test Cases

def test_jinaai_many_valid_models():
    # Test calling jinaai with all valid models in rapid succession
    valid_models = [
        "jina-reranker-v2-base-multilingual",
        "jina-reranker-v1-base-en",
        "jina-reranker-v1-turbo-en",
        "jina-reranker-v1-tiny-en",
        "jina-colbert-v1-en",
    ]
    results = []
    for i in range(200):  # 200 < 1000, as per instructions
        m = valid_models[i % len(valid_models)]
        codeflash_output = _Reranker.jinaai(model=m); result = codeflash_output # 193μs -> 188μs (2.99% faster)
        results.append(result)
    # All results should have the expected model
    for i, r in enumerate(results):
        pass


def test_jinaai_performance_under_load():
    # Test performance does not degrade with many calls (function is trivial, but test for scalability)
    valid_models = [
        "jina-reranker-v2-base-multilingual",
        "jina-reranker-v1-base-en",
        "jina-reranker-v1-turbo-en",
        "jina-reranker-v1-tiny-en",
        "jina-colbert-v1-en",
    ]
    # 500 calls, alternating valid and None
    for i in range(500):
        m = valid_models[i % len(valid_models)] if i % 2 == 0 else None
        codeflash_output = _Reranker.jinaai(model=m); result = codeflash_output # 465μs -> 425μs (9.25% faster)
        if m is None:
            pass
        else:
            pass
# 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 Literal, Optional, Union

# imports
import pytest
from weaviate.collections.classes.config import _Reranker

RerankerJinaAIModel = Literal[
    "jina-reranker-v2-base-multilingual",
    "jina-reranker-v1-base-en",
    "jina-reranker-v1-turbo-en",
    "jina-reranker-v1-tiny-en",
    "jina-colbert-v1-en",
]

# Dummy _RerankerProvider and _RerankerJinaAIConfig for testing purposes.
class _RerankerProvider:
    pass

class _RerankerJinaAIConfig(_RerankerProvider):
    def __init__(self, model=None):
        self.model = model

    def __eq__(self, other):
        # Equality for test assertions
        return isinstance(other, _RerankerJinaAIConfig) and self.model == other.model

    def __repr__(self):
        return f"_RerankerJinaAIConfig(model={self.model!r})"
from weaviate.collections.classes.config import _Reranker

# unit tests

# 1. Basic Test Cases

def test_default_model_none():
    """Test default behavior when no model is provided."""
    codeflash_output = _Reranker.jinaai(); result = codeflash_output # 5.69μs -> 5.66μs (0.459% faster)

@pytest.mark.parametrize("model_name", [
    "jina-reranker-v2-base-multilingual",
    "jina-reranker-v1-base-en",
    "jina-reranker-v1-turbo-en",
    "jina-reranker-v1-tiny-en",
    "jina-colbert-v1-en",
])
def test_valid_literal_models(model_name):
    """Test all valid model names from RerankerJinaAIModel."""
    codeflash_output = _Reranker.jinaai(model=model_name); result = codeflash_output # 23.3μs -> 25.4μs (8.43% slower)

def test_model_as_none_explicit():
    """Test passing None explicitly as model."""
    codeflash_output = _Reranker.jinaai(model=None); result = codeflash_output # 4.29μs -> 4.35μs (1.47% slower)

def test_model_as_valid_str_not_literal():
    """Test passing a valid model as a string (not as a Literal)."""
    model = "jina-reranker-v1-base-en"
    codeflash_output = _Reranker.jinaai(model=model); result = codeflash_output # 4.26μs -> 4.87μs (12.5% slower)

# 2. Edge Test Cases

def test_model_as_invalid_string():
    """Test passing an invalid model string."""
    invalid_model = "invalid-model-name"
    codeflash_output = _Reranker.jinaai(model=invalid_model); result = codeflash_output # 5.24μs -> 5.46μs (3.97% slower)


def test_model_as_empty_string():
    """Test passing an empty string as model."""
    codeflash_output = _Reranker.jinaai(model=""); result = codeflash_output # 10.3μs -> 10.6μs (2.75% slower)







def test_model_as_long_string():
    """Test passing a very long string as model."""
    long_model = "jina-reranker-" + "x" * 900
    codeflash_output = _Reranker.jinaai(model=long_model); result = codeflash_output # 10.4μs -> 10.7μs (2.99% slower)

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testcollectiontest_batch_py_testcollectiontest_classes_generative_py_testcollectiontest_confi__replay_test_0.py::test_weaviate_collections_classes_config__Reranker_jinaai	12.3μs	12.4μs	-0.744%⚠️

To edit these changes git checkout codeflash/optimize-_Reranker.jinaai-mh351l67 and push.