⚡️ Speed up method ShowErrorsCommand.get_command_name by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for ShowErrorsCommand.get_command_name in nvflare/private/fed/client/admin_commands.py

⏱️ Runtime : 312 microseconds → 272 microseconds (best of 235 runs)

📝 Explanation and details

The optimized code introduces a module-level constant caching optimization by storing AdminCommandNames.SHOW_ERRORS in a private variable _SHOW_ERRORS at import time, rather than performing the attribute lookup on every method call.

Key optimization:

• Eliminated repeated attribute lookups: Instead of accessing AdminCommandNames.SHOW_ERRORS each time get_command_name() is called, the value is cached in _SHOW_ERRORS when the module is loaded
• Faster variable access: Local/module-level variable lookup is significantly faster than attribute resolution in Python

Performance impact:

• Line profiler shows 17% reduction in per-call time (258.2ns → 214.4ns per hit)
• Overall 14% speedup in runtime (312μs → 272μs)

Why this works:
In Python, attribute access (obj.attr) involves dictionary lookups and potential method resolution, while local variable access is a direct array index operation. Since AdminCommandNames.SHOW_ERRORS is a constant that never changes, caching it eliminates redundant work.

Test case benefits:
The optimization shows consistent improvements across all test patterns:

• Single calls: 11-82% faster for individual method invocations
• High-frequency scenarios: 15% faster for tests with 1000+ repeated calls, making it particularly beneficial for applications that frequently query command names
• Multiple instances: 14% improvement when many ShowErrorsCommand objects are created

This is a classic Python performance pattern for frequently-accessed constants.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from nvflare.private.fed.client.admin_commands import ShowErrorsCommand


# Simulate the AdminCommandNames class as in nvflare.apis.fl_constant
class AdminCommandNames:
    SHOW_ERRORS = "show_errors"
    # Add a few more for mutation testing and robustness
    START = "start"
    STOP = "stop"
    RESTART = "restart"

# Simulate the CommandProcessor base class
class CommandProcessor:
    pass
from nvflare.private.fed.client.admin_commands import ShowErrorsCommand

# ---------------------------
# Unit tests for get_command_name
# ---------------------------

# 1. Basic Test Cases

def test_get_command_name_returns_show_errors():
    """
    Basic test: Ensure get_command_name returns the expected string.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 664ns -> 371ns (79.0% faster)

def test_get_command_name_type():
    """
    Basic test: Ensure the return type is str.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 412ns -> 338ns (21.9% faster)

def test_get_command_name_is_equal_to_AdminCommandNames():
    """
    Basic test: Ensure returned value matches AdminCommandNames.SHOW_ERRORS constant.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 365ns -> 324ns (12.7% faster)

# 2. Edge Test Cases

def test_get_command_name_is_not_other_commands():
    """
    Edge test: Ensure get_command_name does not return other command names.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 332ns -> 299ns (11.0% faster)
    # Should not return any other admin command
    other_commands = [
        AdminCommandNames.START,
        AdminCommandNames.STOP,
        AdminCommandNames.RESTART,
        "",
        None,
        "SHOW_ERRORS",  # case-sensitive
        "Show_Errors",
        "show-errors",
        "show errors",
        "Show Errors",
    ]
    for other in other_commands:
        pass

def test_get_command_name_is_case_sensitive():
    """
    Edge test: Ensure the returned value is case-sensitive.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 344ns -> 278ns (23.7% faster)

def test_get_command_name_with_multiple_instances():
    """
    Edge test: Ensure multiple instances return the same value.
    """
    cmds = [ShowErrorsCommand() for _ in range(10)]
    results = [cmd.get_command_name() for cmd in cmds]
    for res in results:
        pass

def test_get_command_name_is_not_callable():
    """
    Edge test: Ensure the returned value is not callable.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 701ns -> 384ns (82.6% faster)

def test_get_command_name_is_not_None():
    """
    Edge test: Ensure the returned value is not None.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 422ns -> 311ns (35.7% faster)

def test_get_command_name_does_not_mutate_state():
    """
    Edge test: Ensure calling get_command_name does not alter object state.
    """
    cmd = ShowErrorsCommand()
    before = cmd.__dict__.copy()
    codeflash_output = cmd.get_command_name(); _ = codeflash_output # 384ns -> 300ns (28.0% faster)
    after = cmd.__dict__.copy()

# 3. Large Scale Test Cases

def test_get_command_name_many_calls():
    """
    Large scale: Call get_command_name 1000 times and ensure it always returns the correct value.
    """
    cmd = ShowErrorsCommand()
    for i in range(1000):
        codeflash_output = cmd.get_command_name(); result = codeflash_output # 147μs -> 128μs (15.0% faster)

def test_get_command_name_many_instances():
    """
    Large scale: Create 1000 instances and ensure get_command_name returns correct value for each.
    """
    cmds = [ShowErrorsCommand() for _ in range(1000)]
    for i, cmd in enumerate(cmds):
        codeflash_output = cmd.get_command_name(); result = codeflash_output # 149μs -> 131μs (14.1% faster)

def test_get_command_name_memory_efficiency():
    """
    Large scale: Ensure calling get_command_name on many instances does not cause memory errors.
    """
    try:
        cmds = [ShowErrorsCommand() for _ in range(1000)]
        results = [cmd.get_command_name() for cmd in cmds]
    except MemoryError:
        pytest.fail("get_command_name caused a MemoryError with 1000 instances")

# 4. Mutation-resistance Test Cases

def test_get_command_name_mutation_resistance():
    """
    Mutation-resistance: Ensure get_command_name returns exactly AdminCommandNames.SHOW_ERRORS and nothing else.
    """
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 705ns -> 394ns (78.9% faster)

# 5. Miscellaneous/Negative Test Cases

def test_get_command_name_not_accepting_arguments():
    """
    Negative test: Ensure get_command_name does not accept any arguments.
    """
    cmd = ShowErrorsCommand()
    with pytest.raises(TypeError):
        cmd.get_command_name("unexpected_argument") # 3.15μs -> 3.57μs (11.7% slower)

def test_get_command_name_not_staticmethod():
    """
    Negative test: Ensure get_command_name cannot be called as a static method.
    """
    with pytest.raises(TypeError):
        ShowErrorsCommand.get_command_name() # 2.56μs -> 3.01μs (15.2% slower)


#------------------------------------------------
import pytest
from nvflare.private.fed.client.admin_commands import ShowErrorsCommand


# Simulate the AdminCommandNames enum/class for testing purposes
class AdminCommandNames:
    SHOW_ERRORS = "show_errors"
    RESTART = "restart"
    SHUTDOWN = "shutdown"
    # Add a few more for edge/negative testing
    EMPTY = ""
    NONE = None

# Simulate the CommandProcessor base class
class CommandProcessor:
    pass
from nvflare.private.fed.client.admin_commands import ShowErrorsCommand

# unit tests

# 1. Basic Test Cases

def test_get_command_name_returns_show_errors():
    """Test that get_command_name returns the correct command name."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 651ns -> 401ns (62.3% faster)

def test_get_command_name_type_is_str():
    """Test that the returned command name is a string."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 432ns -> 351ns (23.1% faster)

def test_get_command_name_not_other_admin_commands():
    """Test that get_command_name does not return other admin command names."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 372ns -> 279ns (33.3% faster)
    forbidden = [
        AdminCommandNames.RESTART,
        AdminCommandNames.SHUTDOWN,
        AdminCommandNames.EMPTY,
        None,
        "",
        "SHOW_ERRORS",  # wrong case
        "Show_Errors",  # wrong case
        "showerror",    # typo
        "show_errors ", # trailing space
    ]

# 2. Edge Test Cases

def test_get_command_name_is_not_none():
    """Test that get_command_name never returns None."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 390ns -> 284ns (37.3% faster)

def test_get_command_name_is_not_empty_string():
    """Test that get_command_name never returns an empty string."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 373ns -> 294ns (26.9% faster)

def test_get_command_name_is_case_sensitive():
    """Test that get_command_name is case sensitive and matches the expected case."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 355ns -> 298ns (19.1% faster)

def test_get_command_name_has_no_whitespace():
    """Test that get_command_name does not return a string with leading/trailing whitespace."""
    cmd = ShowErrorsCommand()
    codeflash_output = cmd.get_command_name(); result = codeflash_output # 378ns -> 285ns (32.6% faster)

def test_get_command_name_is_immutable():
    """Test that get_command_name returns the same value on repeated calls."""
    cmd = ShowErrorsCommand()
    results = [cmd.get_command_name() for _ in range(10)] # 390ns -> 333ns (17.1% faster)

def test_get_command_name_does_not_depend_on_instance_state():
    """Test that get_command_name is not affected by instance attribute changes."""
    cmd = ShowErrorsCommand()
    cmd.some_attr = "test"
    codeflash_output = cmd.get_command_name(); result1 = codeflash_output # 362ns -> 284ns (27.5% faster)
    cmd.some_attr = "changed"
    codeflash_output = cmd.get_command_name(); result2 = codeflash_output # 212ns -> 206ns (2.91% faster)

# 3. Large Scale Test Cases

def test_get_command_name_many_instances():
    """Test that many instances of ShowErrorsCommand all return the correct command name."""
    cmds = [ShowErrorsCommand() for _ in range(500)]  # create 500 instances
    results = [cmd.get_command_name() for cmd in cmds]

def test_get_command_name_many_calls():
    """Test that repeated calls to get_command_name are consistent and efficient."""
    cmd = ShowErrorsCommand()
    # Call get_command_name 1000 times and ensure all results are the same
    results = [cmd.get_command_name() for _ in range(1000)] # 703ns -> 342ns (106% faster)

def test_get_command_name_performance_under_load(benchmark):
    """Performance test: get_command_name should be efficient under repeated calls."""
    cmd = ShowErrorsCommand()
    # Use pytest-benchmark to measure performance of 1000 calls
    def call_many():
        for _ in range(1000):
            codeflash_output = cmd.get_command_name()
    benchmark(call_many)
# 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-ShowErrorsCommand.get_command_name-mhcubcz5 and push.