⚡️ Speed up method Algorithms.get by 15%

[codeflash-ai]

📄 15% (0.15x) speedup for Algorithms.get in src/titiler/core/titiler/core/algorithm/__init__.py

⏱️ Runtime : 453 microseconds → 394 microseconds (best of 250 runs)

📝 Explanation and details

This optimization replaces the "look-before-you-leap" (LBYL) pattern with "easier to ask for forgiveness than permission" (EAFP), which is more Pythonic and performant.

Key optimization: The original code performs two dictionary lookups - first name not in self.data to check existence, then self.data[name] to retrieve the value. The optimized version uses try/except to perform only one lookup in the success case.

Why it's faster: Dictionary lookups involve hash computation and collision handling. By eliminating the redundant membership test, we reduce CPU cycles and improve cache locality. The line profiler shows the total time decreased from 1.20ms to 1.03ms (14% speedup).

Performance characteristics:

• Success cases (majority): Significant speedup (5-101% faster across test cases) because only one hash lookup occurs
• Failure cases (KeyError): Slight slowdown (22-47% slower) due to exception handling overhead, but this is typically the minority case
• Large scale workloads: 17-20% improvement when processing many successful lookups

Impact on workloads: This optimization is particularly beneficial for code paths where the algorithm name is expected to exist most of the time (happy path optimization). The test results show consistent improvements for valid lookups across different data sizes, making this especially valuable if this method is called frequently in algorithm resolution workflows.

The behavior remains identical - same KeyError message and type signature are preserved.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Dict, Type

import attr
# imports
import pytest  # used for our unit tests
from titiler.core.algorithm.__init__ import Algorithms

# Minimal BaseAlgorithm stub for type compatibility
class BaseAlgorithm:
    pass

# Example algorithms for testing
class AlgoA(BaseAlgorithm):
    pass

class AlgoB(BaseAlgorithm):
    pass
from titiler.core.algorithm.__init__ import Algorithms

# unit tests

# ----------- BASIC TEST CASES -----------

def test_get_returns_correct_algorithm():
    """
    Basic: Should return the correct algorithm class for a valid name.
    """
    algos = Algorithms(data={'a': AlgoA, 'b': AlgoB})
    codeflash_output = algos.get('a') # 496ns -> 402ns (23.4% faster)
    codeflash_output = algos.get('b') # 346ns -> 172ns (101% faster)

def test_get_with_single_entry():
    """
    Basic: Should work when only one algorithm is present.
    """
    algos = Algorithms(data={'single': AlgoA})
    codeflash_output = algos.get('single') # 480ns -> 400ns (20.0% faster)

def test_get_returns_class_type():
    """
    Basic: Should return the class type, not an instance.
    """
    algos = Algorithms(data={'a': AlgoA})
    codeflash_output = algos.get('a'); result = codeflash_output # 482ns -> 409ns (17.8% faster)

# ----------- EDGE TEST CASES -----------

def test_get_raises_keyerror_for_missing_name():
    """
    Edge: Should raise KeyError for a name not in the dictionary.
    """
    algos = Algorithms(data={'a': AlgoA})
    with pytest.raises(KeyError) as excinfo:
        algos.get('b') # 1.14μs -> 1.70μs (32.9% slower)

def test_get_with_empty_dict_raises_keyerror():
    """
    Edge: Should raise KeyError when data dict is empty.
    """
    algos = Algorithms(data={})
    with pytest.raises(KeyError) as excinfo:
        algos.get('anything') # 1.01μs -> 1.55μs (34.8% slower)

def test_get_with_special_character_names():
    """
    Edge: Should handle names with special characters.
    """
    algos = Algorithms(data={'@lg0!': AlgoA, '123_abc': AlgoB})
    codeflash_output = algos.get('@lg0!') # 506ns -> 393ns (28.8% faster)
    codeflash_output = algos.get('123_abc') # 210ns -> 176ns (19.3% faster)

def test_get_with_case_sensitive_names():
    """
    Edge: Should be case-sensitive for algorithm names.
    """
    algos = Algorithms(data={'Case': AlgoA, 'case': AlgoB})
    codeflash_output = algos.get('Case') # 496ns -> 398ns (24.6% faster)
    codeflash_output = algos.get('case') # 221ns -> 185ns (19.5% faster)
    with pytest.raises(KeyError):
        algos.get('CASE') # 847ns -> 1.34μs (36.7% slower)

def test_get_with_long_name():
    """
    Edge: Should handle long string names.
    """
    long_name = 'a' * 256
    algos = Algorithms(data={long_name: AlgoA})
    codeflash_output = algos.get(long_name) # 455ns -> 432ns (5.32% faster)

def test_get_with_non_string_name():
    """
    Edge: Should raise KeyError if non-string name (not present).
    """
    algos = Algorithms(data={'1': AlgoA})
    with pytest.raises(KeyError):
        algos.get(1) # 1.23μs -> 1.75μs (29.5% slower)

def test_get_with_none_name():
    """
    Edge: Should raise KeyError if None is passed as name.
    """
    algos = Algorithms(data={'None': AlgoA})
    with pytest.raises(KeyError):
        algos.get(None) # 1.22μs -> 1.69μs (27.4% slower)

def test_get_with_empty_string_name():
    """
    Edge: Should handle empty string as valid name if present.
    """
    algos = Algorithms(data={'': AlgoB})
    codeflash_output = algos.get('') # 506ns -> 427ns (18.5% faster)
    with pytest.raises(KeyError):
        algos.get(' ') # 903ns -> 1.36μs (33.7% slower)

# ----------- LARGE SCALE TEST CASES -----------

def test_get_with_large_number_of_algorithms():
    """
    Large Scale: Should handle a large dictionary of algorithms efficiently.
    """
    # Create 1000 dummy algorithms
    class DummyAlgo(BaseAlgorithm):
        pass

    algos_dict = {f"algo_{i}": DummyAlgo for i in range(1000)}
    algos = Algorithms(data=algos_dict)
    # Check a few random entries
    codeflash_output = algos.get("algo_0") # 633ns -> 454ns (39.4% faster)
    codeflash_output = algos.get("algo_999") # 363ns -> 276ns (31.5% faster)
    codeflash_output = algos.get("algo_500") # 202ns -> 166ns (21.7% faster)
    # Check for non-existent entry
    with pytest.raises(KeyError):
        algos.get("algo_1000") # 829ns -> 1.35μs (38.5% slower)

def test_get_performance_large_scale():
    """
    Large Scale: Should be fast for large number of entries.
    """
    import time
    class DummyAlgo(BaseAlgorithm):
        pass
    algos_dict = {f"algo_{i}": DummyAlgo for i in range(1000)}
    algos = Algorithms(data=algos_dict)
    start = time.time()
    for i in range(1000):
        codeflash_output = algos.get(f"algo_{i}") # 207μs -> 176μs (17.6% faster)
    duration = time.time() - start

def test_get_with_duplicate_class_types():
    """
    Large Scale: Should handle multiple names pointing to the same class.
    """
    algos_dict = {f"dup_{i}": AlgoA for i in range(1000)}
    algos = Algorithms(data=algos_dict)
    for i in range(0, 1000, 100):
        codeflash_output = algos.get(f"dup_{i}") # 2.60μs -> 2.23μs (16.8% faster)

def test_get_with_mixed_class_types():
    """
    Large Scale: Should distinguish between different class types.
    """
    algos_dict = {}
    for i in range(500):
        algos_dict[f"A_{i}"] = AlgoA
    for i in range(500, 1000):
        algos_dict[f"B_{i}"] = AlgoB
    algos = Algorithms(data=algos_dict)
    codeflash_output = algos.get("A_0") # 520ns -> 479ns (8.56% faster)
    codeflash_output = algos.get("A_499") # 267ns -> 304ns (12.2% slower)
    codeflash_output = algos.get("B_500") # 354ns -> 198ns (78.8% faster)
    codeflash_output = algos.get("B_999") # 187ns -> 166ns (12.7% faster)
    with pytest.raises(KeyError):
        algos.get("C_1000") # 888ns -> 1.68μs (47.0% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import attr
# imports
import pytest  # used for our unit tests
from titiler.core.algorithm.__init__ import Algorithms

# --- Minimal stubs to allow unit testing ---
# BaseAlgorithm stub for type compatibility
class BaseAlgorithm:
    pass

# Example subclasses for testing
class AlgoA(BaseAlgorithm):
    pass

class AlgoB(BaseAlgorithm):
    pass

class NotAnAlgorithm:
    pass
from titiler.core.algorithm.__init__ import Algorithms

# unit tests

# --- Basic Test Cases ---

def test_get_returns_correct_algorithm():
    # Test that get returns the correct class for a valid key
    algos = Algorithms(data={"a": AlgoA, "b": AlgoB})
    codeflash_output = algos.get("a") # 472ns -> 456ns (3.51% faster)
    codeflash_output = algos.get("b") # 334ns -> 176ns (89.8% faster)

def test_get_with_single_entry():
    # Test with only one algorithm in the data
    algos = Algorithms(data={"x": AlgoA})
    codeflash_output = algos.get("x") # 512ns -> 418ns (22.5% faster)

def test_get_returns_exact_class():
    # Ensure returned class is exactly what's in the dict, not an instance
    algos = Algorithms(data={"a": AlgoA})
    codeflash_output = algos.get("a"); result = codeflash_output # 470ns -> 430ns (9.30% faster)

# --- Edge Test Cases ---

def test_get_with_nonexistent_key_raises_keyerror():
    # Test that KeyError is raised for missing key
    algos = Algorithms(data={"a": AlgoA})
    with pytest.raises(KeyError) as excinfo:
        algos.get("b") # 1.13μs -> 1.70μs (33.4% slower)

def test_get_with_empty_data_raises_keyerror():
    # Test that KeyError is raised if data is empty
    algos = Algorithms(data={})
    with pytest.raises(KeyError) as excinfo:
        algos.get("a") # 1.04μs -> 1.46μs (28.3% slower)

def test_get_with_key_is_none():
    # Test that None as key raises KeyError
    algos = Algorithms(data={"a": AlgoA})
    with pytest.raises(KeyError) as excinfo:
        algos.get(None) # 1.20μs -> 1.68μs (28.4% slower)

def test_get_with_key_is_empty_string():
    # Test that empty string as key raises KeyError unless present
    algos = Algorithms(data={"": AlgoA, "a": AlgoB})
    # If present, should return
    codeflash_output = algos.get("") # 505ns -> 441ns (14.5% faster)
    # If not present, should raise
    algos2 = Algorithms(data={"a": AlgoA})
    with pytest.raises(KeyError):
        algos2.get("") # 831ns -> 1.34μs (38.1% slower)

def test_get_with_non_string_key():
    # Test that non-string keys work if present in data (dict keys can be any hashable)
    algos = Algorithms(data={1: AlgoA, (2,3): AlgoB})
    codeflash_output = algos.get(1) # 619ns -> 477ns (29.8% faster)
    codeflash_output = algos.get((2,3)) # 331ns -> 250ns (32.4% faster)
    with pytest.raises(KeyError):
        algos.get(2) # 937ns -> 1.31μs (28.7% slower)

def test_get_with_non_algorithm_value():
    # Test that get returns the value even if it's not a BaseAlgorithm subclass (type hint not enforced at runtime)
    algos = Algorithms(data={"bad": NotAnAlgorithm})
    # Should return the class, but it's not a BaseAlgorithm
    codeflash_output = algos.get("bad") # 508ns -> 435ns (16.8% faster)

# --- Large Scale Test Cases ---

def test_get_with_large_number_of_algorithms():
    # Test with a large number of algorithms (1000 entries)
    class DummyAlgo(BaseAlgorithm): pass
    data = {f"algo_{i}": type(f"Algo_{i}", (DummyAlgo,), {}) for i in range(1000)}
    algos = Algorithms(data=data)
    # Test some random keys
    codeflash_output = algos.get("algo_0").__name__ # 791ns -> 717ns (10.3% faster)
    codeflash_output = algos.get("algo_999").__name__ # 280ns -> 236ns (18.6% faster)
    # Test missing key
    with pytest.raises(KeyError):
        algos.get("algo_1000") # 1.40μs -> 1.80μs (22.2% slower)

def test_get_performance_large_scale():
    # Test that get is efficient for large datasets (dict lookup is O(1))
    import time
    class DummyAlgo(BaseAlgorithm): pass
    data = {str(i): DummyAlgo for i in range(1000)}
    algos = Algorithms(data=data)
    start = time.time()
    for i in range(1000):
        codeflash_output = algos.get(str(i)) # 208μs -> 173μs (19.8% faster)
    duration = time.time() - start

def test_get_with_long_string_keys():
    # Test with very long string keys
    long_key = "x" * 500
    algos = Algorithms(data={long_key: AlgoA})
    codeflash_output = algos.get(long_key) # 556ns -> 443ns (25.5% faster)
    with pytest.raises(KeyError):
        algos.get("x" * 499) # 1.16μs -> 1.91μs (39.6% slower)

def test_get_with_special_characters_in_key():
    # Test with special/unicode characters in keys
    algos = Algorithms(data={"spécial!@#": AlgoA, "空": AlgoB})
    codeflash_output = algos.get("spécial!@#") # 475ns -> 425ns (11.8% faster)
    codeflash_output = algos.get("空") # 239ns -> 183ns (30.6% faster)
    with pytest.raises(KeyError):
        algos.get("不存在") # 1.16μs -> 1.73μs (33.0% slower)

# --- Additional Robustness Cases ---

def test_get_is_case_sensitive():
    # Test that get is case-sensitive
    algos = Algorithms(data={"Test": AlgoA, "test": AlgoB})
    codeflash_output = algos.get("Test") # 474ns -> 388ns (22.2% faster)
    codeflash_output = algos.get("test") # 232ns -> 192ns (20.8% faster)
    with pytest.raises(KeyError):
        algos.get("TEST") # 805ns -> 1.34μs (39.9% slower)

def test_get_does_not_modify_data():
    # Ensure get does not mutate the data dict
    algos = Algorithms(data={"a": AlgoA})
    before = dict(algos.data)
    codeflash_output = algos.get("a"); _ = codeflash_output # 489ns -> 395ns (23.8% faster)
    after = dict(algos.data)

def test_get_with_mutable_key():
    # Test that using a mutable key raises TypeError (dict keys must be hashable)
    algos = Algorithms(data={"a": AlgoA})
    with pytest.raises(TypeError):
        algos.get(["list", "as", "key"]) # 1.34μs -> 1.81μs (26.1% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from titiler.core.algorithm.__init__ import Algorithms
import pytest

def test_Algorithms_get():
    with pytest.raises(KeyError, match="'Invalid\\ name:\\ '"):
        Algorithms.get(Algorithms({}), '')

🔎 Concolic Coverage Tests and Runtime

To edit these changes git checkout codeflash/optimize-Algorithms.get-miflw6q2 and push.