⚡️ Speed up method Factory.keys by 11%

[codeflash-ai]

📄 11% (0.11x) speedup for Factory.keys in graphrag/factory/factory.py

⏱️ Runtime : 67.6 microseconds → 61.0 microseconds (best of 446 runs)

📝 Explanation and details

The optimization replaces list(self._services.keys()) with list(self._services) in the keys() method. This change eliminates an unnecessary method call since iterating over a dictionary directly yields its keys, making the explicit .keys() call redundant.

Key optimization:

• Direct dictionary iteration: list(self._services) directly converts the dictionary's keys to a list without the intermediate .keys() method call
• Reduced function call overhead: Eliminates one method lookup and call per invocation

Why it's faster:
In Python, when you iterate over a dictionary directly (e.g., for key in dict or list(dict)), it automatically iterates over the keys. The .keys() method creates a dictionary view object that then gets converted to a list, adding an extra layer of abstraction and method call overhead.

Performance characteristics:
The optimization shows consistent 10-50% speedup across different scenarios:

• Small dictionaries (1-3 keys): 28-54% faster due to reduced overhead being more significant relative to total work
• Large dictionaries (1000 keys): 2-7% faster as the iteration cost dominates, but still measurable improvement
• Empty dictionaries: 18-28% faster since overhead reduction is the primary factor

This micro-optimization is most beneficial for frequently called methods on smaller to medium-sized dictionaries where method call overhead represents a meaningful portion of execution time.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from abc import ABC
from collections.abc import Callable
from typing import Any, ClassVar, Generic, TypeVar

# imports
import pytest  # used for our unit tests
from graphrag.factory.factory import Factory

# function to test
# Copyright (c) 2025 Microsoft Corporation.
# Licensed under the MIT License


T = TypeVar("T", covariant=True)
from graphrag.factory.factory import Factory

# unit tests

# Helper subclass to instantiate Factory (since Factory is abstract)
class MyFactory(Factory[int]):
    pass

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

def test_keys_empty_factory():
    # Test that keys returns an empty list when no strategies are registered
    f = MyFactory()
    codeflash_output = f.keys() # 1.15μs -> 900ns (28.2% faster)

def test_keys_single_strategy():
    # Test that keys returns a single-element list when one strategy is registered
    f = MyFactory()
    f._services["foo"] = lambda: 1
    codeflash_output = f.keys() # 957ns -> 714ns (34.0% faster)

def test_keys_multiple_strategies():
    # Test that keys returns all registered strategy names
    f = MyFactory()
    f._services["foo"] = lambda: 1
    f._services["bar"] = lambda: 2
    f._services["baz"] = lambda: 3
    codeflash_output = f.keys(); keys = codeflash_output # 968ns -> 713ns (35.8% faster)
    expected = ["foo", "bar", "baz"]

def test_keys_returns_new_list_each_time():
    # Test that keys returns a new list instance on each call (not the same object)
    f = MyFactory()
    f._services["foo"] = lambda: 1
    codeflash_output = f.keys(); k1 = codeflash_output # 911ns -> 734ns (24.1% faster)
    codeflash_output = f.keys(); k2 = codeflash_output # 392ns -> 350ns (12.0% faster)

def test_keys_after_adding_strategy():
    # Test that keys reflects changes after adding a new strategy
    f = MyFactory()
    f._services["foo"] = lambda: 1
    codeflash_output = f.keys() # 976ns -> 701ns (39.2% faster)
    f._services["bar"] = lambda: 2
    codeflash_output = f.keys() # 372ns -> 268ns (38.8% faster)

def test_keys_after_removing_strategy():
    # Test that keys reflects changes after removing a strategy
    f = MyFactory()
    f._services["foo"] = lambda: 1
    f._services["bar"] = lambda: 2
    codeflash_output = set(f.keys()) # 882ns -> 668ns (32.0% faster)
    del f._services["foo"]
    codeflash_output = f.keys() # 453ns -> 451ns (0.443% faster)

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

def test_keys_with_non_string_keys():
    # Test that keys only returns string keys (should not be possible, but test for robustness)
    f = MyFactory()
    f._services[123] = lambda: 1  # type: ignore
    f._services["abc"] = lambda: 2
    codeflash_output = f.keys(); keys = codeflash_output # 949ns -> 633ns (49.9% faster)

def test_keys_with_special_character_keys():
    # Test that keys handles keys with special characters
    f = MyFactory()
    special_keys = ["", " ", "foo-bar", "foo_bar", "!@#$%^&*()", "こんにちは", "ключ"]
    for k in special_keys:
        f._services[k] = lambda: 1
    codeflash_output = f.keys(); keys = codeflash_output # 1.00μs -> 695ns (44.6% faster)
    for k in special_keys:
        pass

def test_keys_with_duplicate_registration():
    # Test that registering the same key overwrites and does not duplicate
    f = MyFactory()
    f._services["foo"] = lambda: 1
    f._services["foo"] = lambda: 2
    codeflash_output = f.keys(); keys = codeflash_output # 935ns -> 606ns (54.3% faster)

def test_keys_with_long_keys():
    # Test that keys handles very long string keys
    f = MyFactory()
    long_key = "x" * 1000
    f._services[long_key] = lambda: 1
    codeflash_output = f.keys() # 1.04μs -> 784ns (33.0% faster)

def test_keys_with_mutation_of_returned_list():
    # Test that mutating the returned list does not affect internal state
    f = MyFactory()
    f._services["foo"] = lambda: 1
    codeflash_output = f.keys(); k = codeflash_output # 969ns -> 823ns (17.7% faster)
    k.append("bar")
    codeflash_output = f.keys() # 438ns -> 404ns (8.42% faster)

def test_keys_on_multiple_factory_instances():
    # Test that two Factory instances share the same keys (singleton)
    f1 = MyFactory()
    f2 = MyFactory()
    f1._services["foo"] = lambda: 1
    codeflash_output = f2.keys() # 1.04μs -> 735ns (41.2% faster)

def test_keys_after_clearing_services():
    # Test that keys returns empty list after clearing all services
    f = MyFactory()
    f._services["foo"] = lambda: 1
    f._services.clear()
    codeflash_output = f.keys() # 719ns -> 566ns (27.0% faster)

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

def test_keys_large_number_of_strategies():
    # Test keys with a large number of registered strategies (1000)
    f = MyFactory()
    for i in range(1000):
        f._services[f"key_{i}"] = lambda x=i: x
    codeflash_output = f.keys(); keys = codeflash_output # 4.05μs -> 3.93μs (3.18% faster)
    for i in range(1000):
        pass

def test_keys_large_keys_and_values():
    # Test keys with large string keys and large number of strategies
    f = MyFactory()
    for i in range(500):
        k = "k" * 100 + str(i)
        f._services[k] = lambda x=i: x
    codeflash_output = f.keys(); keys = codeflash_output # 5.87μs -> 5.52μs (6.29% faster)
    for i in range(500):
        k = "k" * 100 + str(i)

def test_keys_performance_with_many_operations():
    # Test keys remains correct after many add/remove operations
    f = MyFactory()
    for i in range(500):
        f._services[f"key_{i}"] = lambda x=i: x
    for i in range(250):
        del f._services[f"key_{i}"]
    codeflash_output = f.keys(); keys = codeflash_output # 5.39μs -> 5.41μs (0.296% slower)
    for i in range(250, 500):
        pass

def test_keys_no_side_effects_on_large_scale():
    # Test that repeated calls to keys do not mutate internal state
    f = MyFactory()
    for i in range(1000):
        f._services[f"key_{i}"] = lambda x=i: x
    codeflash_output = f.keys(); k1 = codeflash_output # 6.16μs -> 6.02μs (2.44% faster)
    codeflash_output = f.keys(); k2 = codeflash_output # 4.84μs -> 4.77μs (1.45% faster)
    k1.append("not_a_key")
    codeflash_output = len(f.keys()) # 4.66μs -> 4.62μs (1.04% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from abc import ABC
from collections.abc import Callable
from typing import Any, ClassVar, Generic, TypeVar

# imports
import pytest  # used for our unit tests
from graphrag.factory.factory import Factory

# function to test
# Copyright (c) 2025 Microsoft Corporation.
# Licensed under the MIT License


T = TypeVar("T", covariant=True)
from graphrag.factory.factory import Factory

# unit tests

# Helper function to reset singleton between tests
def reset_factory_singleton(cls):
    cls._instance = None

@pytest.fixture(autouse=True)
def reset_singleton():
    # Reset the singleton before each test to ensure isolation
    reset_factory_singleton(Factory)
    yield
    reset_factory_singleton(Factory)

# --- Basic Test Cases ---

def test_keys_empty_services():
    """Test keys() returns empty list when no services are registered."""
    factory = Factory()
    codeflash_output = factory.keys() # 638ns -> 537ns (18.8% faster)

def test_keys_single_service():
    """Test keys() returns correct list with one service."""
    factory = Factory()
    factory._services['foo'] = lambda: 42
    codeflash_output = factory.keys() # 623ns -> 525ns (18.7% faster)

def test_keys_multiple_services():
    """Test keys() returns all registered service names."""
    factory = Factory()
    factory._services['foo'] = lambda: 1
    factory._services['bar'] = lambda: 2
    factory._services['baz'] = lambda: 3
    codeflash_output = factory.keys(); keys = codeflash_output # 650ns -> 528ns (23.1% faster)

def test_keys_order_is_dict_order():
    """Test keys() preserves insertion order (Python 3.7+ dicts)."""
    factory = Factory()
    factory._services['a'] = lambda: None
    factory._services['b'] = lambda: None
    factory._services['c'] = lambda: None
    codeflash_output = factory.keys() # 650ns -> 497ns (30.8% faster)

# --- Edge Test Cases ---

def test_keys_with_non_string_keys():
    """Test keys() only returns string keys (should not happen, but test for robustness)."""
    factory = Factory()
    factory._services[123] = lambda: 'int key'
    factory._services[None] = lambda: 'none key'
    factory._services['valid'] = lambda: 'valid key'
    # The method expects str keys, but the dict can contain others. It will return all keys as-is.
    codeflash_output = factory.keys(); keys = codeflash_output # 601ns -> 523ns (14.9% faster)

def test_keys_with_empty_string_key():
    """Test keys() returns empty string key if present."""
    factory = Factory()
    factory._services[''] = lambda: 'empty'
    codeflash_output = factory.keys() # 647ns -> 499ns (29.7% faster)

def test_keys_with_special_characters():
    """Test keys() returns keys with special characters."""
    factory = Factory()
    factory._services['!@#$%^&*()'] = lambda: 'special'
    factory._services['\n\t'] = lambda: 'whitespace'
    codeflash_output = factory.keys(); keys = codeflash_output # 641ns -> 525ns (22.1% faster)

def test_keys_after_removal():
    """Test keys() reflects removal of keys."""
    factory = Factory()
    factory._services['foo'] = lambda: 1
    factory._services['bar'] = lambda: 2
    del factory._services['foo']
    codeflash_output = factory.keys() # 675ns -> 568ns (18.8% faster)

def test_keys_with_duplicate_keys():
    """Test keys() does not have duplicates (dict keys are unique)."""
    factory = Factory()
    factory._services['dup'] = lambda: 1
    factory._services['dup'] = lambda: 2  # Overwrites previous
    codeflash_output = factory.keys(); keys = codeflash_output # 644ns -> 497ns (29.6% faster)

def test_keys_with_long_string_keys():
    """Test keys() with very long string keys."""
    long_key = 'x' * 1000
    factory = Factory()
    factory._services[long_key] = lambda: 'long'
    codeflash_output = factory.keys() # 649ns -> 484ns (34.1% faster)

# --- Large Scale Test Cases ---

def test_keys_large_number_of_services():
    """Test keys() with a large number of services (1000)."""
    factory = Factory()
    for i in range(1000):
        factory._services[f'key_{i}'] = lambda x=i: x
    codeflash_output = factory.keys(); keys = codeflash_output # 4.16μs -> 3.88μs (7.26% faster)

def test_keys_performance_large_scale():
    """Test keys() performance does not degrade with large dict (1000 keys)."""
    import time
    factory = Factory()
    for i in range(1000):
        factory._services[f'k{i}'] = lambda: i
    start = time.time()
    codeflash_output = factory.keys(); result = codeflash_output # 3.92μs -> 3.77μs (4.04% faster)
    duration = time.time() - start

def test_keys_with_large_and_varied_keys():
    """Test keys() with a mix of long, short, special, and numeric string keys."""
    factory = Factory()
    keys_to_add = [
        'short', 'S'*500, '123', '!@#, 'with space', 'ümläut', 'key\nnewline', 'key\tTab'
    ]
    for k in keys_to_add:
        factory._services[k] = lambda: k
    for i in range(992):  # fill up to 1000
        factory._services[f'auto_{i}'] = lambda: i
    codeflash_output = factory.keys(); keys = codeflash_output # 3.83μs -> 3.75μs (2.11% faster)
    # All custom keys present
    for k in keys_to_add:
        pass

# --- Singleton/Isolation Test Cases ---

def test_factory_singleton_isolation(reset_singleton):
    """Test that Factory singleton does not leak state between instances."""
    f1 = Factory()
    f2 = Factory()
    f1._services['foo'] = lambda: 1
    codeflash_output = f2.keys() # 677ns -> 603ns (12.3% faster)
    # Reset and check isolation
    reset_factory_singleton(Factory)
    f3 = Factory()
    codeflash_output = f3.keys() # 326ns -> 255ns (27.8% faster)

def test_keys_after_reinitialization(reset_singleton):
    """Test keys() after Factory is reinitialized."""
    f1 = Factory()
    f1._services['a'] = lambda: 1
    reset_factory_singleton(Factory)
    f2 = Factory()
    codeflash_output = f2.keys() # 629ns -> 514ns (22.4% faster)

# --- Mutation/Robustness Test Cases ---

def test_keys_returns_new_list_each_time():
    """Test that keys() returns a new list object each call."""
    factory = Factory()
    factory._services['x'] = lambda: 1
    codeflash_output = factory.keys(); list1 = codeflash_output # 649ns -> 501ns (29.5% faster)
    codeflash_output = factory.keys(); list2 = codeflash_output # 298ns -> 273ns (9.16% faster)

def test_keys_not_affected_by_external_mutation():
    """Test that mutating the returned list does not affect Factory._services."""
    factory = Factory()
    factory._services['foo'] = lambda: 1
    codeflash_output = factory.keys(); keys = codeflash_output # 628ns -> 457ns (37.4% faster)
    keys.append('bar')
    codeflash_output = factory.keys() # 295ns -> 282ns (4.61% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from graphrag.factory.factory import Factory

def test_Factory_keys():
    Factory.keys(Factory())

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_3eu3lmds/tmp4w5d1n2u/test_concolic_coverage.py::test_Factory_keys	605ns	535ns	13.1%✅

To edit these changes git checkout codeflash/optimize-Factory.keys-mglgaudb and push.