⚡️ Speed up method KeepKeyPlugin.get_client by 13%

[codeflash-ai]

📄 13% (0.13x) speedup for KeepKeyPlugin.get_client in electrum/plugins/keepkey/keepkey.py

⏱️ Runtime : 21.6 milliseconds → 19.2 milliseconds (best of 35 runs)

📝 Explanation and details

The optimization achieves a 12% speedup by eliminating redundant method calls through device manager caching.

Key optimization:

• Cached device manager access: The original code called self.device_manager() on every get_client() invocation, which involved a method call overhead. The optimized version caches self.parent.device_manager as self._device_manager during initialization and accesses it directly.

Performance impact:

• Line profiler shows the devmgr = self.device_manager() line dropped from 893,101ns to 374,238ns per hit (58% faster)
• With 1,435 calls in the profile, this single optimization saves ~0.5ms total
• The method call elimination is particularly effective because get_client() appears to be called frequently in hardware wallet operations

Why this works:

• Method call overhead: Python method calls have inherent overhead (attribute lookup, frame creation, etc.)
• Immutable reference: The device manager reference doesn't change during the plugin's lifetime, making caching safe
• Hot path optimization: The annotated tests show this function being called hundreds to thousands of times, amplifying the per-call savings

Test case benefits:

• Most effective on high-frequency scenarios like the "many consecutive calls" test (14.7ms → 12.8ms, 14.7% faster)
• Consistent 1-3% improvements across individual calls
• Particularly beneficial for hardware wallet workflows that repeatedly query device status or perform multiple operations

The optimization maintains full backward compatibility while providing measurable performance gains in hardware wallet intensive operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from electrum.plugins.keepkey.keepkey import KeepKeyPlugin


# Minimal stubs for dependencies (since we cannot use pytest.mock, we define concrete classes)
class DummyHandler:
    def __init__(self):
        self.used_called = False

class DummyKeystore:
    def __init__(self, handler=None):
        self.handler = handler if handler else DummyHandler()

class DummyClient:
    def __init__(self):
        self.used_called = False
    def used(self):
        self.used_called = True

class DummyDeviceMgr:
    def __init__(self):
        self.calls = []
        self.return_client = None
    def client_for_keystore(self, plugin, handler, keystore, force_pair, devices=None, allow_user_interaction=True):
        # Log the call for test verification
        self.calls.append({
            'plugin': plugin,
            'handler': handler,
            'keystore': keystore,
            'force_pair': force_pair,
            'devices': devices,
            'allow_user_interaction': allow_user_interaction
        })
        return self.return_client

class DummyParent:
    def __init__(self, devmgr):
        self.device_manager = devmgr
from electrum.plugins.keepkey.keepkey import KeepKeyPlugin

# ==========================
# Unit Tests for KeepKeyPlugin.get_client
# ==========================

# -------- Basic Test Cases --------
def test_get_client_returns_client_and_calls_used():
    """Test normal case: get_client returns a client and calls used() on it."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 47.8μs -> 46.6μs (2.64% faster)

def test_get_client_returns_none_when_no_client():
    """Test case: device_manager returns None, get_client should return None and not call used()."""
    devmgr = DummyDeviceMgr()
    devmgr.return_client = None
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 46.9μs -> 46.2μs (1.65% faster)

def test_get_client_passes_arguments_correctly():
    """Test that get_client passes all arguments to device_manager.client_for_keystore."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    devices = ["dev1", "dev2"]
    codeflash_output = plugin.get_client(keystore, force_pair=False, devices=devices, allow_user_interaction=False); result = codeflash_output # 48.3μs -> 47.7μs (1.16% faster)
    call = devmgr.calls[-1]

# -------- Edge Test Cases --------
def test_get_client_with_none_keystore_handler():
    """Test edge case: keystore.handler is None (should not fail)."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    class NoHandlerKeystore:
        handler = None
    keystore = NoHandlerKeystore()
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 48.1μs -> 47.4μs (1.57% faster)

def test_get_client_with_devices_none_and_empty():
    """Test edge case: devices argument is None and empty list."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    # devices=None
    codeflash_output = plugin.get_client(keystore, devices=None); result_none = codeflash_output # 47.5μs -> 47.9μs (0.810% slower)
    # devices=[]
    codeflash_output = plugin.get_client(keystore, devices=[]); result_empty = codeflash_output # 25.8μs -> 25.9μs (0.363% slower)

def test_get_client_with_nonstandard_handler_object():
    """Test edge case: keystore.handler is not a DummyHandler instance."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    class StrangeHandler:
        pass
    keystore = DummyKeystore(handler=StrangeHandler())
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 47.1μs -> 46.7μs (0.845% faster)

def test_get_client_with_nonstandard_keystore_object():
    """Test edge case: keystore is not a DummyKeystore instance but has a handler attribute."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    class CustomKeystore:
        def __init__(self):
            self.handler = DummyHandler()
    keystore = CustomKeystore()
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 47.7μs -> 47.0μs (1.62% faster)

def test_get_client_with_unusual_types():
    """Test edge case: devices is a tuple, allow_user_interaction is not boolean."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    devices = ("devA", "devB")
    codeflash_output = plugin.get_client(keystore, devices=devices, allow_user_interaction="yes"); result = codeflash_output # 48.4μs -> 48.3μs (0.327% faster)
    call = devmgr.calls[-1]

# -------- Large Scale Test Cases --------
def test_get_client_many_devices():
    """Test large scale: devices argument is a large list."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    devices = [f"dev_{i}" for i in range(1000)]
    codeflash_output = plugin.get_client(keystore, devices=devices); result = codeflash_output # 47.8μs -> 47.8μs (0.004% faster)
    call = devmgr.calls[-1]

def test_get_client_many_calls():
    """Test large scale: repeatedly call get_client with different keystores."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    for i in range(1000):
        keystore = DummyKeystore()
        codeflash_output = plugin.get_client(keystore, force_pair=bool(i % 2)); result = codeflash_output # 14.7ms -> 12.8ms (14.7% faster)
        client.used_called = False  # Reset for next iteration

def test_get_client_performance_large_keystore_objects():
    """Test large scale: keystore objects with large attributes."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    class LargeHandler:
        def __init__(self):
            self.data = "x" * 10000  # Large attribute
    class LargeKeystore:
        def __init__(self):
            self.handler = LargeHandler()
            self.biglist = [i for i in range(1000)]  # Large list attribute
    keystore = LargeKeystore()
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 48.2μs -> 47.3μs (1.91% faster)

# -------- Deterministic/Negative Test Cases --------
def test_get_client_deterministic_behavior():
    """Test that repeated calls with same inputs produce same outputs."""
    devmgr = DummyDeviceMgr()
    client = DummyClient()
    devmgr.return_client = client
    plugin = KeepKeyPlugin(DummyParent(devmgr), config={}, name="keepkey")
    keystore = DummyKeystore()
    results = []
    for _ in range(10):
        codeflash_output = plugin.get_client(keystore); result = codeflash_output # 227μs -> 221μs (2.41% faster)
        results.append(result)
        client.used_called = False

from typing import Any, List, Optional

# imports
import pytest
from electrum.plugins.keepkey.keepkey import KeepKeyPlugin

# --- Minimal stubs and fakes to enable testing without external dependencies ---

class FakeHandler:
    """A fake handler to simulate keystore.handler."""
    pass

class FakeDevice:
    """A fake device object."""
    def __init__(self, path):
        self.path = path

class FakeClient:
    """A fake client object to simulate hardware client."""
    def __init__(self, keystore, plugin, used_flag=None):
        self.keystore = keystore
        self.plugin = plugin
        self.used_flag = used_flag or []
    def used(self):
        self.used_flag.append(True)

class FakeDeviceMgr:
    """A fake device manager to simulate client_for_keystore logic."""
    def __init__(self):
        # Records the last call for assertion
        self.last_call = None
        self.return_client = None
    def client_for_keystore(self, plugin, handler, keystore, force_pair, devices=None, allow_user_interaction=True):
        self.last_call = {
            "plugin": plugin,
            "handler": handler,
            "keystore": keystore,
            "force_pair": force_pair,
            "devices": devices,
            "allow_user_interaction": allow_user_interaction,
        }
        return self.return_client

class FakeParent:
    """A fake parent that provides a device_manager."""
    def __init__(self, devmgr):
        self.device_manager = devmgr

class FakeKeyStore:
    """A fake keystore with a handler."""
    def __init__(self, handler=None):
        self.handler = handler or FakeHandler()
from electrum.plugins.keepkey.keepkey import KeepKeyPlugin

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

@pytest.fixture
def devmgr():
    """Fixture for a fresh FakeDeviceMgr."""
    return FakeDeviceMgr()

@pytest.fixture
def parent(devmgr):
    """Fixture for a parent with a device manager."""
    return FakeParent(devmgr)

@pytest.fixture
def plugin(parent):
    """Fixture for the KeepKeyPlugin."""
    return KeepKeyPlugin(parent, config={}, name="keepkey")

@pytest.fixture
def keystore():
    """Fixture for a FakeKeyStore."""
    return FakeKeyStore()

# ---- 1. Basic Test Cases ----

def test_returns_client_and_calls_used(plugin, devmgr, keystore):
    """Should return the client from device manager and call client.used()."""
    used_flag = []
    client = FakeClient(keystore, plugin, used_flag=used_flag)
    devmgr.return_client = client
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 49.3μs -> 49.5μs (0.257% slower)

def test_returns_none_when_no_client(plugin, devmgr, keystore):
    """Should return None if device manager returns None."""
    devmgr.return_client = None
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 46.8μs -> 45.9μs (2.01% faster)

def test_passes_all_arguments(plugin, devmgr, keystore):
    """Should pass all arguments through to device manager."""
    devmgr.return_client = FakeClient(keystore, plugin)
    devices = [FakeDevice("dev1"), FakeDevice("dev2")]
    codeflash_output = plugin.get_client(keystore, force_pair=False, devices=devices, allow_user_interaction=False); result = codeflash_output # 48.3μs -> 48.3μs (0.008% faster)
    last_call = devmgr.last_call

# ---- 2. Edge Test Cases ----

def test_keystore_without_handler(plugin, devmgr):
    """Should raise AttributeError if keystore has no handler attribute."""
    class NoHandlerKeystore:
        pass
    devmgr.return_client = FakeClient(None, plugin)
    with pytest.raises(AttributeError):
        plugin.get_client(NoHandlerKeystore()) # 48.9μs -> 48.7μs (0.365% faster)

def test_devices_argument_empty_list(plugin, devmgr, keystore):
    """Should handle devices=[] correctly."""
    devmgr.return_client = FakeClient(keystore, plugin)
    codeflash_output = plugin.get_client(keystore, devices=[]); result = codeflash_output # 48.4μs -> 48.2μs (0.413% faster)
    last_call = devmgr.last_call

def test_devices_argument_none(plugin, devmgr, keystore):
    """Should handle devices=None correctly (default)."""
    devmgr.return_client = FakeClient(keystore, plugin)
    codeflash_output = plugin.get_client(keystore, devices=None); result = codeflash_output # 48.8μs -> 48.4μs (0.957% faster)
    last_call = devmgr.last_call

def test_allow_user_interaction_false(plugin, devmgr, keystore):
    """Should pass allow_user_interaction=False correctly."""
    devmgr.return_client = FakeClient(keystore, plugin)
    codeflash_output = plugin.get_client(keystore, allow_user_interaction=False); result = codeflash_output # 48.8μs -> 48.2μs (1.05% faster)
    last_call = devmgr.last_call

def test_force_pair_true_and_false(plugin, devmgr, keystore):
    """Should pass force_pair argument correctly for both True and False."""
    devmgr.return_client = FakeClient(keystore, plugin)
    plugin.get_client(keystore, force_pair=True) # 49.0μs -> 48.4μs (1.27% faster)
    plugin.get_client(keystore, force_pair=False) # 25.4μs -> 25.4μs (0.177% faster)

def test_multiple_clients_used_flag(plugin, devmgr, keystore):
    """Should call used() only on the returned client, not on others."""
    used_flags = [[] for _ in range(3)]
    clients = [FakeClient(keystore, plugin, used_flag=used_flags[i]) for i in range(3)]
    for c in clients:
        c.used_flag.clear()
    devmgr.return_client = clients[1]
    codeflash_output = plugin.get_client(keystore); result = codeflash_output # 48.2μs -> 47.1μs (2.35% faster)

def test_keystore_handler_is_none(plugin, devmgr):
    """Should handle keystore with handler set to None (should pass None to device manager)."""
    ks = FakeKeyStore(handler=None)
    devmgr.return_client = FakeClient(ks, plugin)
    codeflash_output = plugin.get_client(ks); result = codeflash_output # 48.2μs -> 47.7μs (1.02% faster)

# ---- 3. Large Scale Test Cases ----

def test_many_devices_argument(plugin, devmgr, keystore):
    """Should handle a large list of devices (scalability test)."""
    devices = [FakeDevice(f"dev{i}") for i in range(500)]
    devmgr.return_client = FakeClient(keystore, plugin)
    codeflash_output = plugin.get_client(keystore, devices=devices); result = codeflash_output # 48.5μs -> 49.2μs (1.27% slower)

def test_many_consecutive_calls(plugin, devmgr, keystore):
    """Should behave correctly for many consecutive calls (performance and determinism)."""
    for i in range(100):
        used_flag = []
        client = FakeClient(keystore, plugin, used_flag=used_flag)
        devmgr.return_client = client
        codeflash_output = plugin.get_client(keystore, force_pair=(i % 2 == 0), allow_user_interaction=(i % 3 == 0)); result = codeflash_output # 1.52ms -> 1.37ms (11.1% faster)

def test_large_keystore_objects(plugin, devmgr):
    """Should handle keystore objects with large attributes."""
    class LargeHandler:
        def __init__(self):
            self.data = "x" * 10000  # Large attribute
    class LargeKeyStore:
        def __init__(self):
            self.handler = LargeHandler()
    ks = LargeKeyStore()
    devmgr.return_client = FakeClient(ks, plugin)
    codeflash_output = plugin.get_client(ks); result = codeflash_output # 48.2μs -> 47.7μs (0.956% faster)

def test_large_number_of_clients(plugin, devmgr, keystore):
    """Should only call used() on the correct client among many."""
    clients = [FakeClient(keystore, plugin, used_flag=[]) for _ in range(300)]
    for idx, client in enumerate(clients):
        devmgr.return_client = client
        codeflash_output = plugin.get_client(keystore); result = codeflash_output # 4.03ms -> 3.68ms (9.67% faster)
        # Reset for next iteration
        client.used_flag.clear()
# 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-KeepKeyPlugin.get_client-mhxieuk2 and push.