⚡️ Speed up function _create_mock_context by 17%

[codeflash-ai]

📄 17% (0.17x) speedup for _create_mock_context in pdd/sync_orchestration.py

⏱️ Runtime : 277 microseconds → 237 microseconds (best of 476 runs)

📝 Explanation and details

The optimization introduces command object caching by moving click.Command('sync') creation from inside the function to a module-level constant _SYNC_COMMAND. This eliminates the repeated construction of the same Command object on every function call.

Key Changes:

• Added _SYNC_COMMAND = click.Command('sync') at module level
• Changed click.Context(click.Command('sync')) to click.Context(_SYNC_COMMAND)

Why This Is Faster:
Object creation in Python has overhead - each click.Command('sync') call involves memory allocation, attribute initialization, and potential string processing. By caching this immutable object, we eliminate this repeated work. The line profiler shows the critical line dropped from 15,186ns per hit to 10,967ns per hit (28% improvement on the bottleneck line).

Test Case Performance:

• Small/simple cases: 28-35% speedup (most common usage patterns)
• Large kwargs cases: 2-8% speedup (overhead becomes relatively smaller)
• Repeated calls: Up to 48% speedup on subsequent calls due to reduced allocation pressure

This optimization is particularly effective for frequently called utility functions where the same Command object is recreated unnecessarily, making it ideal for mock/test scenarios where _create_mock_context might be called repeatedly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import click  # needed for click.Context and click.Command
# imports
import pytest  # used for our unit tests
from pdd.sync_orchestration import _create_mock_context

# unit tests

# 1. Basic Test Cases

def test_create_mock_context_empty():
    """Test creation of mock context with no keyword arguments."""
    codeflash_output = _create_mock_context(); ctx = codeflash_output # 6.19μs -> 4.76μs (30.0% faster)

def test_create_mock_context_single_kwarg():
    """Test creation with a single keyword argument."""
    codeflash_output = _create_mock_context(foo=123); ctx = codeflash_output # 5.31μs -> 4.01μs (32.4% faster)

def test_create_mock_context_multiple_kwargs():
    """Test creation with multiple keyword arguments."""
    codeflash_output = _create_mock_context(a=1, b=2, c='three'); ctx = codeflash_output # 5.16μs -> 3.95μs (30.6% faster)

def test_create_mock_context_mutable_kwargs():
    """Test that mutable objects are stored and referenced correctly."""
    d = {'x': 1}
    l = [1, 2, 3]
    codeflash_output = _create_mock_context(my_dict=d, my_list=l); ctx = codeflash_output # 5.02μs -> 3.82μs (31.6% faster)

# 2. Edge Test Cases

def test_create_mock_context_special_char_keys():
    """Test keys with special characters."""
    codeflash_output = _create_mock_context(**{'sp@ce': 42, '': 'empty', '中文': 'chinese'}); ctx = codeflash_output # 4.97μs -> 3.77μs (31.7% faster)

def test_create_mock_context_none_value():
    """Test passing None as a value."""
    codeflash_output = _create_mock_context(foo=None); ctx = codeflash_output # 4.84μs -> 3.69μs (31.0% faster)

def test_create_mock_context_bool_and_zero():
    """Test passing boolean and zero values."""
    codeflash_output = _create_mock_context(flag=False, count=0); ctx = codeflash_output # 4.88μs -> 3.65μs (33.9% faster)

def test_create_mock_context_large_string_key_and_value():
    """Test with very large string as key and value."""
    k = 'k' * 256
    v = 'v' * 1024
    codeflash_output = _create_mock_context(**{k: v}); ctx = codeflash_output # 4.83μs -> 3.58μs (34.9% faster)


def test_create_mock_context_non_str_keys():
    """Test that non-string keys are not allowed in kwargs."""
    # kwargs must have string keys, so this should raise a TypeError
    with pytest.raises(TypeError):
        _create_mock_context(**{1: 'one'})

def test_create_mock_context_reserved_key_obj():
    """Test if 'obj' as a key is handled correctly (should not interfere with ctx.obj)."""
    codeflash_output = _create_mock_context(obj='should_not_conflict'); ctx = codeflash_output # 7.95μs -> 6.19μs (28.4% faster)
    # The context's .obj attribute is still the dict

def test_create_mock_context_reserved_key_command():
    """Test if 'command' as a key is handled correctly (should not interfere with ctx.command)."""
    codeflash_output = _create_mock_context(command='should_not_conflict'); ctx = codeflash_output # 5.40μs -> 4.17μs (29.5% faster)

# 3. Large Scale Test Cases

def test_create_mock_context_many_kwargs():
    """Test creation with a large number of keyword arguments."""
    N = 900  # keep under 1000 as per instructions
    kwargs = {f'key{i}': i for i in range(N)}
    codeflash_output = _create_mock_context(**kwargs); ctx = codeflash_output # 36.7μs -> 35.1μs (4.68% faster)
    for i in range(0, N, 100):  # sample a few keys
        pass

def test_create_mock_context_large_values():
    """Test with large values in the context."""
    big_list = list(range(1000))
    big_dict = {str(i): i for i in range(1000)}
    codeflash_output = _create_mock_context(big_list=big_list, big_dict=big_dict); ctx = codeflash_output # 5.69μs -> 4.47μs (27.3% faster)

def test_create_mock_context_performance_large():
    """Performance test: ensure function is reasonably fast with large input."""
    import time
    N = 999
    kwargs = {f'k{i}': i for i in range(N)}
    start = time.time()
    codeflash_output = _create_mock_context(**kwargs); ctx = codeflash_output # 38.2μs -> 36.8μs (3.89% faster)
    duration = time.time() - start

# 4. Additional Robustness Tests

def test_create_mock_context_obj_is_dict_and_not_shared():
    """Ensure ctx.obj is a dict and not shared between calls."""
    codeflash_output = _create_mock_context(a=1); ctx1 = codeflash_output # 5.29μs -> 4.11μs (28.7% faster)
    codeflash_output = _create_mock_context(b=2); ctx2 = codeflash_output # 3.12μs -> 2.10μs (48.7% faster)
    ctx1.obj['foo'] = 'bar'

def test_create_mock_context_command_is_sync():
    """Ensure the command name is always 'sync'."""
    codeflash_output = _create_mock_context(); ctx = codeflash_output # 4.42μs -> 3.40μs (29.8% faster)

def test_create_mock_context_obj_identity():
    """Ensure the obj attribute is exactly the kwargs dict."""
    codeflash_output = _create_mock_context(x=1, y=2); ctx = codeflash_output # 4.93μs -> 3.74μs (31.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import click  # needed for click.Context and click.Command
# imports
import pytest  # used for our unit tests
from pdd.sync_orchestration import _create_mock_context

# unit tests

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

def test_returns_click_context_instance():
    """Test that the function returns an instance of click.Context."""
    codeflash_output = _create_mock_context(); ctx = codeflash_output # 4.45μs -> 3.33μs (33.8% faster)

def test_context_command_name_is_sync():
    """Test that the context's command name is 'sync'."""
    codeflash_output = _create_mock_context(); ctx = codeflash_output # 4.50μs -> 3.33μs (35.2% faster)

def test_context_obj_is_empty_dict_when_no_kwargs():
    """Test that ctx.obj is an empty dict when no kwargs are provided."""
    codeflash_output = _create_mock_context(); ctx = codeflash_output # 4.48μs -> 3.35μs (33.8% faster)

def test_context_obj_contains_passed_kwargs():
    """Test that ctx.obj contains the correct key-value pairs when kwargs are passed."""
    codeflash_output = _create_mock_context(foo=1, bar='baz'); ctx = codeflash_output # 4.75μs -> 3.72μs (27.7% faster)

def test_context_obj_with_various_types():
    """Test that ctx.obj correctly stores values of various types."""
    codeflash_output = _create_mock_context(a=1, b=2.5, c=[1,2,3], d={'x': 99}, e=None, f=True); ctx = codeflash_output # 5.12μs -> 4.04μs (26.7% faster)
    expected = {'a': 1, 'b': 2.5, 'c': [1,2,3], 'd': {'x': 99}, 'e': None, 'f': True}

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

def test_context_obj_with_special_char_keys():
    """Test that ctx.obj can handle keys with special characters."""
    codeflash_output = _create_mock_context(**{'key-with-dash': 42, 'key with space': 'abc', 'üñîçødë': 'yes'}); ctx = codeflash_output # 4.59μs -> 3.57μs (28.8% faster)
    expected = {'key-with-dash': 42, 'key with space': 'abc', 'üñîçødë': 'yes'}

def test_context_obj_with_mutable_values():
    """Test that ctx.obj stores references to mutable objects."""
    mutable = [1, 2, 3]
    codeflash_output = _create_mock_context(m=mutable); ctx = codeflash_output # 4.48μs -> 3.58μs (25.3% faster)
    # Mutate after context creation
    mutable.append(4)

def test_context_obj_with_empty_string_and_zero():
    """Test that ctx.obj can handle empty string and zero values."""
    codeflash_output = _create_mock_context(empty='', zero=0); ctx = codeflash_output # 4.70μs -> 3.57μs (31.8% faster)

def test_context_obj_with_boolean_keys():
    """Test that boolean keys raise TypeError (since kwargs must be str)."""
    with pytest.raises(TypeError):
        _create_mock_context(**{True: 'yes'})  # type: ignore

def test_context_obj_with_reserved_python_keywords():
    """Test that reserved Python keywords can be used as keys (with trailing underscore)."""
    codeflash_output = _create_mock_context(class_='myclass', def_='mydef'); ctx = codeflash_output # 5.00μs -> 3.86μs (29.6% faster)

def test_context_obj_isolation_between_calls():
    """Test that multiple calls do not share state."""
    codeflash_output = _create_mock_context(a=1); ctx1 = codeflash_output # 4.86μs -> 3.80μs (28.0% faster)
    codeflash_output = _create_mock_context(b=2); ctx2 = codeflash_output # 2.69μs -> 1.96μs (37.5% faster)

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

def test_context_obj_with_many_keys():
    """Test that ctx.obj can handle a large number of keys."""
    data = {f'key{i}': i for i in range(500)}
    codeflash_output = _create_mock_context(**data); ctx = codeflash_output # 21.9μs -> 20.2μs (8.40% faster)

def test_context_obj_with_large_values():
    """Test that ctx.obj can handle large values."""
    big_list = list(range(1000))
    big_str = 'x' * 1000
    codeflash_output = _create_mock_context(big_list=big_list, big_str=big_str); ctx = codeflash_output # 4.96μs -> 3.81μs (30.3% faster)

def test_context_obj_with_nested_large_structures():
    """Test that ctx.obj can handle deeply nested and large structures."""
    nested = {'a': [{'b': [i for i in range(100)]}] * 10}
    codeflash_output = _create_mock_context(nested=nested); ctx = codeflash_output # 4.67μs -> 3.55μs (31.5% faster)

def test_context_obj_performance_large_scale(benchmark):
    """Benchmark performance with large number of keys and values."""
    data = {f'k{i}': i for i in range(900)}
    result = benchmark(_create_mock_context, **data)

# -----------------------
# Determinism and Isolation
# -----------------------

def test_context_obj_isolation_from_external_mutation():
    """Test that modifying the returned ctx.obj does not affect future calls."""
    codeflash_output = _create_mock_context(x=1); ctx1 = codeflash_output # 5.10μs -> 4.04μs (26.5% faster)
    ctx1.obj['x'] = 999
    codeflash_output = _create_mock_context(x=2); ctx2 = codeflash_output # 2.91μs -> 2.06μs (41.5% faster)

# -----------------------
# Negative/Invalid Input Cases
# -----------------------

def test_context_obj_with_non_string_keys_raises():
    """Test that passing non-string keys raises TypeError."""
    with pytest.raises(TypeError):
        _create_mock_context(**{123: 'number'})  # type: ignore

def test_context_obj_with_too_many_arguments():
    """Test that function can handle near-maximum number of kwargs (Python limit is high)."""
    data = {f'k{i}': i for i in range(900)}
    codeflash_output = _create_mock_context(**data); ctx = codeflash_output # 34.8μs -> 33.9μs (2.50% faster)
# 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-_create_mock_context-mgn1mmwb and push.