⚡️ Speed up function build_invocation_context by 19%

[codeflash-ai]

📄 19% (0.19x) speedup for build_invocation_context in invokeai/app/services/shared/invocation_context.py

⏱️ Runtime : 440 microseconds → 369 microseconds (best of 250 runs)

📝 Explanation and details

The optimization reduces function call overhead by eliminating repeated keyword argument creation when instantiating multiple interface objects.

Key Changes:

• Pre-creates a tuple args = (services, data) containing the two most commonly used arguments
• Uses argument unpacking (*args) instead of explicit keyword arguments (services=services, data=data) for 6 out of 8 interface constructors
• Maintains the same functionality while reducing the overhead of creating keyword argument dictionaries

Performance Impact:
The 19% speedup (440μs → 369μs) comes from Python's internal optimization of positional argument passing. When using *args, Python avoids the overhead of:

1. Creating keyword argument dictionaries for each function call
2. Performing keyword-to-positional argument mapping in the called functions
3. Hash table lookups for parameter names

Test Case Performance:
The optimization shows consistent 12-27% improvements across all test scenarios, with particularly strong gains in:

• Large-scale tests with many attributes (20%+ speedup)
• Edge cases with unusual data structures (17-22% speedup)
• Basic creation patterns (12-18% speedup)

This micro-optimization is especially valuable since build_invocation_context appears to be a factory function that creates complex object hierarchies, making the cumulative effect of reducing per-call overhead significant across the 8 interface instantiations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from types import SimpleNamespace
from typing import Callable

# imports
import pytest
from invokeai.app.services.shared.invocation_context import \
    build_invocation_context

# function to test
# (copied from the prompt, with necessary dummy classes for testing)

# Dummy classes to stand in for the real interfaces and context
class LoggerInterface:
    def __init__(self, services, data): self.services, self.data = services, data
class TensorsInterface:
    def __init__(self, services, data): self.services, self.data = services, data
class ConfigInterface:
    def __init__(self, services, data): self.services, self.data = services, data
class UtilInterface:
    def __init__(self, services, data, is_canceled): self.services, self.data, self.is_canceled = services, data, is_canceled
class ConditioningInterface:
    def __init__(self, services, data): self.services, self.data = services, data
class ModelsInterface:
    def __init__(self, services, data, util): self.services, self.data, self.util = services, data, util
class ImagesInterface:
    def __init__(self, services, data, util): self.services, self.data, self.util = services, data, util
class BoardsInterface:
    def __init__(self, services, data): self.services, self.data = services, data

class InvocationContext:
    def __init__(
        self,
        images,
        logger,
        config,
        tensors,
        models,
        data,
        util,
        conditioning,
        services,
        boards,
    ):
        self.images = images
        self.logger = logger
        self.config = config
        self.tensors = tensors
        self.models = models
        self.data = data
        self.util = util
        self.conditioning = conditioning
        self.services = services
        self.boards = boards

# Dummy types for InvocationServices and InvocationContextData
class InvocationServices:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

class InvocationContextData:
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)
from invokeai.app.services.shared.invocation_context import \
    build_invocation_context

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

# 1. BASIC TEST CASES

def test_basic_context_creation():
    """Test that context is created with all expected attributes and correct types."""
    services = InvocationServices(foo="bar")
    data = InvocationContextData(baz=123)
    is_canceled = lambda: False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 9.37μs -> 9.05μs (3.45% faster)

def test_context_data_and_services_passed():
    """Test that data and services are passed to all sub-interfaces."""
    services = InvocationServices(a=1)
    data = InvocationContextData(b=2)
    is_canceled = lambda: False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 6.31μs -> 5.38μs (17.4% faster)

def test_util_interface_receives_is_canceled():
    """Test that UtilInterface receives the is_canceled function."""
    services = InvocationServices()
    data = InvocationContextData()
    called = []
    def is_canceled():
        called.append(True)
        return True
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.74μs -> 5.13μs (11.8% faster)

def test_models_and_images_receive_util():
    """Test that ModelsInterface and ImagesInterface receive the correct util instance."""
    services = InvocationServices()
    data = InvocationContextData()
    is_canceled = lambda: False
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.49μs -> 4.63μs (18.5% faster)

# 2. EDGE TEST CASES

def test_empty_services_and_data():
    """Test with empty services and data objects."""
    services = InvocationServices()
    data = InvocationContextData()
    is_canceled = lambda: False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.37μs -> 4.68μs (14.9% faster)

def test_is_canceled_raises_exception():
    """Test that an exception in is_canceled propagates through UtilInterface."""
    services = InvocationServices()
    data = InvocationContextData()
    def is_canceled():
        raise RuntimeError("cancel check failed")
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.31μs -> 4.44μs (19.7% faster)
    with pytest.raises(RuntimeError):
        ctx.util.is_canceled()

def test_services_and_data_are_mutable():
    """Test that mutating services/data after context creation affects sub-interfaces."""
    services = InvocationServices(x=1)
    data = InvocationContextData(y=2)
    is_canceled = lambda: False
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.35μs -> 4.57μs (17.1% faster)
    services.x = 42
    data.y = 99

def test_services_and_data_with_unusual_attributes():
    """Test services/data with strange attribute names and types."""
    services = InvocationServices(_private=123, __dunder__=456, weird_list=[1,2,3])
    data = InvocationContextData(long_string="x"*100, nested=SimpleNamespace(foo="bar"))
    is_canceled = lambda: False
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.11μs -> 4.38μs (16.6% faster)

def test_is_canceled_returns_various_types():
    """Test is_canceled returning different types (should not be used, but function should accept)."""
    services = InvocationServices()
    data = InvocationContextData()
    for val in [None, 0, 1, "yes", [], {}, object()]:
        codeflash_output = build_invocation_context(services, data, lambda: val); ctx = codeflash_output # 22.9μs -> 19.3μs (18.7% faster)

# 3. LARGE SCALE TEST CASES

def test_large_services_and_data():
    """Test with large numbers of attributes in services and data."""
    # 500 attributes each, well below 1000
    services_attrs = {f"attr_{i}": i for i in range(500)}
    data_attrs = {f"data_{i}": i for i in range(500)}
    services = InvocationServices(**services_attrs)
    data = InvocationContextData(**data_attrs)
    is_canceled = lambda: False
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.71μs -> 4.73μs (20.8% faster)

def test_many_contexts_in_succession():
    """Test creating many contexts in a loop to check for memory/resource leaks."""
    services = InvocationServices(foo="bar")
    data = InvocationContextData(baz=123)
    is_canceled = lambda: False
    contexts = []
    for _ in range(100):  # well below 1000
        codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 288μs -> 238μs (20.8% faster)
        contexts.append(ctx)
    for ctx in contexts:
        pass

def test_large_nested_data():
    """Test with nested data structures in services/data."""
    nested = SimpleNamespace(**{f"n_{i}": i for i in range(200)})
    services = InvocationServices(biglist=list(range(200)), nested=nested)
    data = InvocationContextData(bigdict={str(i): i for i in range(200)})
    is_canceled = lambda: False
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.47μs -> 4.85μs (12.9% faster)

def test_performance_with_large_attributes():
    """Test that function completes quickly with large attribute sets."""
    import time
    services = InvocationServices(**{f"a{i}": i for i in range(900)})
    data = InvocationContextData(**{f"d{i}": i for i in range(900)})
    is_canceled = lambda: False
    start = time.time()
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.77μs -> 5.09μs (13.5% faster)
    duration = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest
from invokeai.app.services.shared.invocation_context import \
    build_invocation_context

# --- Begin mock classes and function definitions ---
# These are minimal implementations to allow the test suite to run.
# In production, these would be imported from the actual codebase.

class InvocationServices:
    """Mock class for InvocationServices."""
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

class InvocationContextData:
    """Mock class for InvocationContextData."""
    def __init__(self, **kwargs):
        self.__dict__.update(kwargs)

class LoggerInterface:
    def __init__(self, services, data): self.services = services; self.data = data
class TensorsInterface:
    def __init__(self, services, data): self.services = services; self.data = data
class ConfigInterface:
    def __init__(self, services, data): self.services = services; self.data = data
class UtilInterface:
    def __init__(self, services, data, is_canceled): self.services = services; self.data = data; self.is_canceled = is_canceled
class ConditioningInterface:
    def __init__(self, services, data): self.services = services; self.data = data
class ModelsInterface:
    def __init__(self, services, data, util): self.services = services; self.data = data; self.util = util
class ImagesInterface:
    def __init__(self, services, data, util): self.services = services; self.data = data; self.util = util
class BoardsInterface:
    def __init__(self, services, data): self.services = services; self.data = data

class InvocationContext:
    def __init__(
        self,
        images,
        logger,
        config,
        tensors,
        models,
        data,
        util,
        conditioning,
        services,
        boards
    ):
        self.images = images
        self.logger = logger
        self.config = config
        self.tensors = tensors
        self.models = models
        self.data = data
        self.util = util
        self.conditioning = conditioning
        self.services = services
        self.boards = boards
from invokeai.app.services.shared.invocation_context import \
    build_invocation_context

# --- End mock classes and function definitions ---

# unit tests

# 1. Basic Test Cases

def test_basic_context_creation():
    """Test that context is created with all expected attributes."""
    services = InvocationServices(a=1)
    data = InvocationContextData(b=2)
    def is_canceled(): return False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.43μs -> 4.83μs (12.4% faster)

def test_context_attributes_linked_correctly():
    """Test that context attributes are linked to the correct input objects."""
    services = InvocationServices(foo='bar')
    data = InvocationContextData(x=123)
    def is_canceled(): return True

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.18μs -> 4.42μs (17.3% faster)

def test_is_canceled_callable_usage():
    """Test that is_canceled is correctly stored and callable in util."""
    services = InvocationServices()
    data = InvocationContextData()
    called = []
    def is_canceled(): called.append(True); return True

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.05μs -> 4.48μs (12.7% faster)
    # Call the is_canceled function via util
    result = ctx.util.is_canceled()

# 2. Edge Test Cases

def test_empty_services_and_data():
    """Test with empty services and data objects."""
    services = InvocationServices()
    data = InvocationContextData()
    def is_canceled(): return False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.18μs -> 4.28μs (21.2% faster)

def test_services_and_data_with_unusual_attributes():
    """Test with services and data containing unusual attributes."""
    services = InvocationServices(_private=42, __hidden__="yes", long_string="x"*100)
    data = InvocationContextData(special_chars="@!#", list_attr=[1,2,3])
    def is_canceled(): return False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.31μs -> 4.36μs (21.7% faster)

def test_is_canceled_raises_exception():
    """Test that an exception in is_canceled propagates."""
    services = InvocationServices()
    data = InvocationContextData()
    def is_canceled(): raise RuntimeError("cancel error")

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.04μs -> 4.22μs (19.7% faster)
    # Calling util.is_canceled should raise
    with pytest.raises(RuntimeError):
        ctx.util.is_canceled()

def test_services_and_data_are_none():
    """Test with services and data set to None."""
    # We expect the interfaces to still be created, but with None attributes
    def is_canceled(): return False
    codeflash_output = build_invocation_context(None, None, is_canceled); ctx = codeflash_output # 5.59μs -> 4.75μs (17.6% faster)

def test_is_canceled_returns_various_types():
    """Test is_canceled returning different types."""
    services = InvocationServices()
    data = InvocationContextData()
    def is_canceled(): return "not a bool"
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.32μs -> 4.51μs (18.0% faster)

# 3. Large Scale Test Cases

def test_large_services_and_data():
    """Test with large number of attributes in services and data."""
    # Create services/data with 1000 attributes each
    services_attrs = {f"attr_{i}": i for i in range(1000)}
    data_attrs = {f"data_{i}": str(i) for i in range(1000)}
    services = InvocationServices(**services_attrs)
    data = InvocationContextData(**data_attrs)
    def is_canceled(): return False

    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 6.94μs -> 5.76μs (20.5% faster)

def test_multiple_contexts_are_independent():
    """Test that multiple contexts with different inputs are independent."""
    services1 = InvocationServices(a=1)
    data1 = InvocationContextData(b=2)
    def is_canceled1(): return False

    services2 = InvocationServices(a=2)
    data2 = InvocationContextData(b=3)
    def is_canceled2(): return True

    codeflash_output = build_invocation_context(services1, data1, is_canceled1); ctx1 = codeflash_output # 5.81μs -> 5.18μs (12.2% faster)
    codeflash_output = build_invocation_context(services2, data2, is_canceled2); ctx2 = codeflash_output # 3.43μs -> 2.71μs (26.4% faster)

def test_context_creation_performance():
    """Test that context creation is reasonably fast for large inputs."""
    import time
    services = InvocationServices(**{f"s_{i}": i for i in range(1000)})
    data = InvocationContextData(**{f"d_{i}": i for i in range(1000)})
    def is_canceled(): return False

    start = time.time()
    codeflash_output = build_invocation_context(services, data, is_canceled); ctx = codeflash_output # 5.94μs -> 5.08μs (17.0% faster)
    duration = time.time() - start
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-build_invocation_context-mhn7r4j1 and push.