⚡️ Speed up method ServerConnectWizard.start by 25%

[codeflash-ai]

📄 25% (0.25x) speedup for ServerConnectWizard.start in electrum/wizard.py

⏱️ Runtime : 993 microseconds → 794 microseconds (best of 64 runs)

📝 Explanation and details

The optimized code achieves a 25% speedup through strategic object reuse and reduced allocations, targeting the most expensive operations identified in the line profiler.

Key Optimizations:

1. Object Reuse in reset() - The biggest performance gain comes from caching a single empty WizardViewState instance (self._empty_viewstate) and reusing it instead of creating new objects every time reset() is called. The profiler shows this reduced the reset() function time from 1.39ms to 0.84ms (39% faster). This eliminates the expensive WizardViewState(None, {}, {}) construction that was consuming 64.8% of reset()'s time.

2. In-place List Operations - Using self._stack.clear() instead of self._stack = [] reuses the existing list object rather than allocating a new empty list. This is more efficient for Python's memory management.

3. Reduced Dictionary Lookups - In start(), caching self.navmap['welcome'] in a local variable (navmap_welcome) reduces redundant dictionary lookups and attribute access overhead.

Performance Impact by Test Case:

• Basic operations show 10-25% improvements, which is significant for frequently called wizard operations
• Custom viewstate scenarios see dramatic 66-77% improvements because they bypass the expensive object creation entirely
• Large-scale tests with 1000+ iterations show 33-54% gains, indicating the optimizations scale well under heavy usage

Why This Matters:
The wizard classes appear to be part of Electrum's user interface flow for server configuration. Since wizards are user-facing components that may be reset/restarted frequently during configuration, these micro-optimizations provide noticeable responsiveness improvements. The object reuse pattern is particularly effective here because the empty state is genuinely reusable - these are immutable initialization values that don't get modified after creation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from electrum.wizard import ServerConnectWizard

# --- Begin: minimal stub implementations for dependencies ---

class WizardViewState:
    """Stub for WizardViewState used in AbstractWizard."""
    def __init__(self, view, data, params):
        self.view = view
        self.data = data
        self.params = params
    def __eq__(self, other):
        return (
            isinstance(other, WizardViewState)
            and self.view == other.view
            and self.data == other.data
            and self.params == other.params
        )
    def __repr__(self):
        return f"WizardViewState({self.view!r}, {self.data!r}, {self.params!r})"
from electrum.wizard import ServerConnectWizard

# --- End: function/class to test ---

# --- Begin: unit tests ---

class DummyDaemon:
    """Minimal stub for Daemon, not used in start()."""
    pass

@pytest.fixture
def wizard():
    """Fixture to create a ServerConnectWizard instance."""
    return ServerConnectWizard(DummyDaemon())

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

def test_start_default_returns_welcome(wizard):
    """Basic: start() with no arguments returns WizardViewState for 'welcome' with empty data/params."""
    codeflash_output = wizard.start(); result = codeflash_output # 1.87μs -> 1.49μs (25.3% faster)

def test_start_with_custom_viewstate(wizard):
    """Basic: start() with a custom WizardViewState returns that exact state."""
    custom_state = WizardViewState('proxy_config', {'foo': 'bar'}, {'baz': 1})
    codeflash_output = wizard.start(start_viewstate=custom_state); result = codeflash_output # 1.54μs -> 925ns (66.9% faster)

def test_start_resets_stack_and_current(wizard):
    """Basic: start() resets the wizard stack and current state."""
    wizard._stack = [WizardViewState('a', {}, {})]
    wizard._current = WizardViewState('b', {}, {})
    wizard.start() # 1.84μs -> 1.60μs (14.8% faster)

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

def test_start_with_none_viewstate(wizard):
    """Edge: Explicitly passing None as start_viewstate behaves like default."""
    codeflash_output = wizard.start(start_viewstate=None); result = codeflash_output # 1.92μs -> 1.64μs (17.2% faster)

def test_start_with_empty_navmap(monkeypatch):
    """Edge: If navmap is empty, start() should raise KeyError."""
    wiz = ServerConnectWizard(DummyDaemon())
    wiz.navmap = {}
    with pytest.raises(KeyError):
        wiz.start() # 1.72μs -> 1.18μs (44.8% faster)

def test_start_with_navmap_missing_params(monkeypatch):
    """Edge: If navmap entry for 'welcome' lacks 'params', params should default to {}."""
    wiz = ServerConnectWizard(DummyDaemon())
    # Remove 'params' from navmap['welcome'] if exists
    wiz.navmap['welcome'].pop('params', None)
    codeflash_output = wiz.start(); result = codeflash_output # 1.59μs -> 1.27μs (25.7% faster)

def test_start_with_navmap_params(monkeypatch):
    """Edge: If navmap entry for 'welcome' has 'params', they are used."""
    wiz = ServerConnectWizard(DummyDaemon())
    wiz.navmap['welcome']['params'] = {'x': 42}
    codeflash_output = wiz.start(); result = codeflash_output # 1.53μs -> 1.29μs (18.9% faster)

def test_start_with_non_wizardviewstate_object(wizard):
    """Edge: Passing a non-WizardViewState object as start_viewstate sets _current to that object."""
    dummy = object()
    codeflash_output = wizard.start(start_viewstate=dummy); result = codeflash_output # 1.50μs -> 956ns (57.0% faster)

def test_start_multiple_calls_are_idempotent(wizard):
    """Edge: Multiple calls to start() always reset state to welcome."""
    wizard._stack = [WizardViewState('foo', {}, {})]
    wizard._current = WizardViewState('bar', {}, {})
    codeflash_output = wizard.start(); first = codeflash_output # 1.84μs -> 1.66μs (11.2% faster)
    codeflash_output = wizard.start(); second = codeflash_output # 852ns -> 699ns (21.9% faster)

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

def test_start_with_large_params(wizard):
    """Large: navmap['welcome']['params'] with a large dict is handled correctly."""
    large_params = {str(i): i for i in range(1000)}
    wizard.navmap['welcome']['params'] = large_params
    codeflash_output = wizard.start(); result = codeflash_output # 1.72μs -> 1.42μs (21.5% faster)

def test_start_with_large_custom_viewstate(wizard):
    """Large: start() with a WizardViewState with large data/params."""
    large_data = {str(i): i for i in range(1000)}
    large_params = {str(i): i for i in range(1000)}
    custom_state = WizardViewState('server_config', large_data, large_params)
    codeflash_output = wizard.start(start_viewstate=custom_state); result = codeflash_output # 1.62μs -> 931ns (74.5% faster)

def test_start_performance_large_number_of_calls(wizard):
    """Large: start() called repeatedly should not leak memory or degrade."""
    for _ in range(1000):
        codeflash_output = wizard.start(); result = codeflash_output # 618μs -> 465μs (33.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 List

# imports
import pytest
from electrum.wizard import ServerConnectWizard


# Minimal stubs and helpers for dependencies
class WizardViewState:
    def __init__(self, view, data, params):
        self.view = view
        self.data = data
        self.params = params

    def __eq__(self, other):
        if not isinstance(other, WizardViewState):
            return False
        return self.view == other.view and self.data == other.data and self.params == other.params

    def __repr__(self):
        return f"WizardViewState({self.view!r}, {self.data!r}, {self.params!r})"

class DummyDaemon:
    def __init__(self):
        self.network = None
        self.config = DummyConfig()

class DummyConfig:
    class cv:
        class NETWORK_AUTO_CONNECT:
            @staticmethod
            def is_modifiable():
                return True
    NETWORK_AUTO_CONNECT = True
from electrum.wizard import ServerConnectWizard

# unit tests

@pytest.fixture
def wizard():
    # Provide a fresh wizard for each test
    return ServerConnectWizard(DummyDaemon())

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

def test_start_default_sets_welcome(wizard):
    """Test that start() with no arguments sets view to 'welcome' and data/params to empty dicts."""
    codeflash_output = wizard.start(); ws = codeflash_output # 2.08μs -> 1.89μs (10.1% faster)

def test_start_with_custom_viewstate(wizard):
    """Test that start() with a custom WizardViewState sets _current to that viewstate."""
    custom = WizardViewState('proxy_config', {'foo': 1}, {'bar': 2})
    codeflash_output = wizard.start(start_viewstate=custom); ws = codeflash_output # 1.67μs -> 978ns (71.2% faster)

def test_start_resets_stack_and_current(wizard):
    """Test that start() resets the stack and sets _current appropriately."""
    # Fill stack and _current with dummy values
    wizard._stack = [WizardViewState('x', {}, {}) for _ in range(3)]
    wizard._current = WizardViewState('y', {'a': 1}, {'b': 2})
    codeflash_output = wizard.start(); ws = codeflash_output # 2.08μs -> 2.00μs (4.15% faster)

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

def test_start_with_empty_navmap(monkeypatch):
    """Test start() when navmap is empty: should raise KeyError."""
    wiz = ServerConnectWizard(DummyDaemon())
    wiz.navmap = {}
    with pytest.raises(KeyError):
        wiz.start() # 1.75μs -> 1.25μs (39.8% faster)

def test_start_with_navmap_missing_params(wizard):
    """Test start() when navmap['welcome'] has no 'params' key (should default to {})."""
    # Remove 'params' if present
    if 'params' in wizard.navmap['welcome']:
        del wizard.navmap['welcome']['params']
    codeflash_output = wizard.start(); ws = codeflash_output # 1.77μs -> 1.51μs (17.7% faster)

def test_start_with_navmap_params(wizard):
    """Test start() when navmap['welcome'] has a 'params' key."""
    wizard.navmap['welcome']['params'] = {'foo': 'bar'}
    codeflash_output = wizard.start(); ws = codeflash_output # 1.70μs -> 1.47μs (15.9% faster)

def test_start_with_none_view_in_viewstate(wizard):
    """Test start() with a WizardViewState having None as view."""
    custom = WizardViewState(None, {}, {})
    codeflash_output = wizard.start(start_viewstate=custom); ws = codeflash_output # 1.51μs -> 876ns (72.4% faster)

def test_start_with_large_data_in_viewstate(wizard):
    """Test start() with a WizardViewState with large data dict."""
    big_data = {str(i): i for i in range(1000)}
    custom = WizardViewState('welcome', big_data, {})
    codeflash_output = wizard.start(start_viewstate=custom); ws = codeflash_output # 1.60μs -> 948ns (68.4% faster)

def test_start_does_not_mutate_passed_viewstate(wizard):
    """Test that start() does not mutate the passed-in WizardViewState."""
    custom = WizardViewState('proxy_config', {'x': 1}, {'y': 2})
    wizard.start(start_viewstate=custom) # 1.44μs -> 809ns (77.9% faster)

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

def test_start_many_times_resets_each_time(wizard):
    """Test repeated calls to start() always reset stack and set _current to welcome."""
    for i in range(100):
        wizard._stack = [WizardViewState(str(j), {}, {}) for j in range(i)]
        wizard._current = WizardViewState('junk', {}, {})
        codeflash_output = wizard.start(); ws = codeflash_output # 252μs -> 232μs (8.68% faster)

def test_start_with_large_params_dict(wizard):
    """Test start() when navmap['welcome'] has a large params dict."""
    big_params = {str(i): i for i in range(1000)}
    wizard.navmap['welcome']['params'] = big_params
    codeflash_output = wizard.start(); ws = codeflash_output # 1.73μs -> 1.41μs (22.8% faster)

def test_start_with_various_viewstates(wizard):
    """Test start() with a variety of WizardViewState inputs."""
    for i in range(100):
        custom = WizardViewState(f'view_{i}', {'n': i}, {'p': i})
        codeflash_output = wizard.start(start_viewstate=custom); ws = codeflash_output # 50.3μs -> 32.6μs (54.3% faster)

def test_start_with_large_stack_and_resets(wizard):
    """Test that start() resets a large stack."""
    wizard._stack = [WizardViewState('v', {}, {}) for _ in range(999)]
    codeflash_output = wizard.start(); ws = codeflash_output # 34.5μs -> 35.2μs (2.21% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from electrum.wizard import ServerConnectWizard

To edit these changes git checkout codeflash/optimize-ServerConnectWizard.start-mhlbgw5h and push.