⚡️ Speed up method Algorithms.list by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for Algorithms.list in src/titiler/core/titiler/core/algorithm/__init__.py

⏱️ Runtime : 40.5 microseconds → 34.9 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces list(self.data.keys()) with [*self.data] to achieve a 15% performance improvement. This works because iterating over a dictionary directly yields its keys, making the unpacking operation [*self.data] equivalent to list(self.data.keys()) but more efficient.

Key optimization details:

• Eliminates the intermediate .keys() method call and the subsequent list() constructor overhead
• Uses Python's unpacking syntax [*...] which directly builds a list from the dictionary's key iterator
• Reduces function call overhead from two operations to one list comprehension with unpacking

Performance characteristics from test results:

• Consistent 25-40% improvements across all test cases, regardless of dictionary size
• Benefits are most pronounced with smaller dictionaries (empty dict: 36.4% faster, single item: 29.6% faster)
• Even scales well to large datasets (1000 items still shows 3-5% improvement)

Impact on existing workloads:
Based on the function references, this list() method is called in web API endpoints for retrieving tile matrix sets (self.supported_tms.list()). These endpoints likely serve HTTP requests where every microsecond counts for user experience. The optimization is particularly valuable since:

• It's called within FastAPI route handlers that process web requests
• Used in list comprehensions that build response data structures
• The 15% speedup directly reduces API response times

The optimization maintains identical behavior and return type while providing consistent performance gains across all use cases.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

🌀 Generated Regression Tests and Runtime

from typing import Dict, List, Type

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

# Minimal BaseAlgorithm stub for type compliance
class BaseAlgorithm:
    pass
from titiler.core.algorithm.__init__ import Algorithms

# unit tests

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

def test_list_with_multiple_algorithms():
    # Test with multiple algorithms registered
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    algos = Algorithms(data={"a": AlgoA, "b": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 824ns -> 622ns (32.5% faster)

def test_list_with_single_algorithm():
    # Test with a single algorithm registered
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"a": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 788ns -> 608ns (29.6% faster)

def test_list_with_no_algorithms():
    # Test with no algorithms registered
    algos = Algorithms(data={})
    codeflash_output = algos.list(); result = codeflash_output # 705ns -> 517ns (36.4% faster)

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

def test_list_with_non_ascii_keys():
    # Test with non-ASCII keys
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    algos = Algorithms(data={"α": AlgoA, "β": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 720ns -> 558ns (29.0% faster)

def test_list_with_empty_string_key():
    # Test with empty string as a key
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 698ns -> 561ns (24.4% faster)

def test_list_with_special_character_keys():
    # Test with special character keys
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    algos = Algorithms(data={"!@#": AlgoA, " ": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 729ns -> 533ns (36.8% faster)

def test_list_with_keys_that_are_python_keywords():
    # Test with keys that are Python keywords
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    algos = Algorithms(data={"class": AlgoA, "def": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 716ns -> 514ns (39.3% faster)

def test_list_with_duplicate_algorithm_classes():
    # Test with different keys pointing to the same class
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"a": AlgoA, "b": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 708ns -> 514ns (37.7% faster)

def test_list_is_not_the_same_object_as_keys():
    # Ensure list() returns a new list, not a reference to the underlying dict keys
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"a": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 701ns -> 511ns (37.2% faster)
    # Mutating result should not affect the Algorithms object
    result.append("b")
    codeflash_output = algos.list() # 272ns -> 250ns (8.80% faster)

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

def test_list_with_many_algorithms():
    # Test with a large number of algorithms registered (up to 1000)
    class Algo(BaseAlgorithm): pass
    keys = [f"algo_{i}" for i in range(1000)]
    data = {key: Algo for key in keys}
    algos = Algorithms(data=data)
    codeflash_output = algos.list(); result = codeflash_output # 3.94μs -> 3.77μs (4.51% faster)

def test_list_performance_with_large_data():
    # Ensure performance is acceptable with large data (not a real perf test, but checks output)
    class Algo(BaseAlgorithm): pass
    keys = [str(i) for i in range(999)]
    data = {key: Algo for key in keys}
    algos = Algorithms(data=data)
    codeflash_output = algos.list(); result = codeflash_output # 3.92μs -> 3.72μs (5.41% faster)

# ----------- Determinism and Robustness -----------

def test_list_returns_deterministic_order():
    # Python 3.7+ dict preserves insertion order; test that order is preserved
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    class AlgoC(BaseAlgorithm): pass
    algos = Algorithms(data={"first": AlgoA, "second": AlgoB, "third": AlgoC})
    codeflash_output = algos.list(); result = codeflash_output # 663ns -> 538ns (23.2% faster)

def test_list_with_mixed_type_keys():
    # Only str keys are allowed by type, but test with str keys that look like numbers
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    algos = Algorithms(data={"1": AlgoA, "2": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 654ns -> 533ns (22.7% faster)

# ----------- Defensive: Type Safety -----------

def test_list_with_non_algorithm_type_should_fail():
    # If non-BaseAlgorithm type is used, it should still list the key (type is not enforced at runtime)
    class NotAnAlgorithm: pass
    algos = Algorithms(data={"bad": NotAnAlgorithm})
    codeflash_output = algos.list(); result = codeflash_output # 733ns -> 534ns (37.3% faster)

def test_list_with_none_as_value():
    # None as value should not break the function, as only keys are returned
    algos = Algorithms(data={"none": None})
    codeflash_output = algos.list(); result = codeflash_output # 667ns -> 473ns (41.0% 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, List, Type

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

class BaseAlgorithm:
    """Dummy base class for algorithms."""
    pass
from titiler.core.algorithm.__init__ import Algorithms

# unit tests

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

def test_list_with_single_algorithm():
    # Test with one algorithm registered
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"algo_a": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 700ns -> 497ns (40.8% faster)

def test_list_with_multiple_algorithms():
    # Test with multiple algorithms registered
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    class AlgoC(BaseAlgorithm): pass
    algos = Algorithms(data={"a": AlgoA, "b": AlgoB, "c": AlgoC})
    codeflash_output = algos.list(); result = codeflash_output # 740ns -> 539ns (37.3% faster)

def test_list_with_no_algorithms():
    # Test with no algorithms registered
    algos = Algorithms(data={})
    codeflash_output = algos.list(); result = codeflash_output # 684ns -> 522ns (31.0% faster)

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

def test_list_with_non_string_keys():
    # Test with non-string keys (should work, but not recommended)
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={1: AlgoA, (2,3): AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 684ns -> 547ns (25.0% faster)

def test_list_with_empty_string_key():
    # Test with an empty string as key
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={"": AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 718ns -> 541ns (32.7% faster)

def test_list_with_duplicate_keys():
    # Test with duplicate keys (should not be possible, but test overwriting)
    class AlgoA(BaseAlgorithm): pass
    class AlgoB(BaseAlgorithm): pass
    # Python dict cannot have duplicate keys; last one wins
    algos = Algorithms(data={"dup": AlgoA, "dup": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 714ns -> 528ns (35.2% faster)

def test_list_with_large_key_names():
    # Test with very long string keys
    class AlgoA(BaseAlgorithm): pass
    long_key = "a" * 1000
    algos = Algorithms(data={long_key: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 697ns -> 544ns (28.1% faster)

def test_list_with_special_character_keys():
    # Test with keys containing special characters
    class AlgoA(BaseAlgorithm): pass
    special_key = "!@#$%^&*()_+-=[]{}|;':,.<>/?"
    algos = Algorithms(data={special_key: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 676ns -> 515ns (31.3% faster)

def test_list_with_none_key():
    # Test with None as a key
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={None: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 757ns -> 562ns (34.7% faster)

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

def test_list_with_many_algorithms():
    # Test with a large number of algorithms (1000)
    class AlgoA(BaseAlgorithm): pass
    keys = [f"algo_{i}" for i in range(1000)]
    data = {k: AlgoA for k in keys}
    algos = Algorithms(data=data)
    codeflash_output = algos.list(); result = codeflash_output # 3.94μs -> 3.79μs (3.69% faster)

def test_list_performance_with_large_data():
    # Test performance/scalability with 1000 elements
    import time
    class AlgoA(BaseAlgorithm): pass
    keys = [f"algo_{i}" for i in range(1000)]
    data = {k: AlgoA for k in keys}
    algos = Algorithms(data=data)
    start = time.time()
    codeflash_output = algos.list(); result = codeflash_output # 3.86μs -> 3.73μs (3.35% faster)
    duration = time.time() - start

def test_list_with_mixed_type_keys_large():
    # Test with 1000 mixed type keys
    class AlgoA(BaseAlgorithm): pass
    keys = []
    data = {}
    for i in range(500):
        data[i] = AlgoA
        keys.append(i)
    for i in range(500, 1000):
        k = f"algo_{i}"
        data[k] = AlgoA
        keys.append(k)
    algos = Algorithms(data=data)
    codeflash_output = algos.list(); result = codeflash_output # 3.97μs -> 3.76μs (5.59% faster)

# -------------------- ADDITIONAL EDGE CASES --------------------

def test_list_with_unusual_basealgorithm_subclasses():
    # Test with subclasses that override __str__/__repr__
    class AlgoA(BaseAlgorithm):
        def __str__(self): return "AlgoA"
        def __repr__(self): return "AlgoA"
    class AlgoB(BaseAlgorithm):
        def __str__(self): return "AlgoB"
        def __repr__(self): return "AlgoB"
    algos = Algorithms(data={"a": AlgoA, "b": AlgoB})
    codeflash_output = algos.list(); result = codeflash_output # 710ns -> 559ns (27.0% faster)

def test_list_with_object_key():
    # Test with object instance as key
    class AlgoA(BaseAlgorithm): pass
    key_obj = object()
    algos = Algorithms(data={key_obj: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 690ns -> 552ns (25.0% faster)

def test_list_with_bool_keys():
    # Test with bool keys
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={True: AlgoA, False: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 690ns -> 546ns (26.4% faster)

def test_list_with_float_keys():
    # Test with float keys
    class AlgoA(BaseAlgorithm): pass
    algos = Algorithms(data={1.1: AlgoA, 2.2: AlgoA})
    codeflash_output = algos.list(); result = codeflash_output # 686ns -> 482ns (42.3% faster)
# 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

def test_Algorithms_list():
    Algorithms.list(Algorithms({}))

🔎 Concolic Coverage Tests and Runtime

To edit these changes git checkout codeflash/optimize-Algorithms.list-miflznda and push.