⚡️ Speed up method JobTargetType.get_target_type by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for JobTargetType.get_target_type in nvflare/job_config/defs.py

⏱️ Runtime : 1.72 milliseconds → 1.48 milliseconds (best of 84 runs)

📝 Explanation and details

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest  # used for our unit tests
from nvflare.job_config.defs import JobTargetType

# unit tests

# Basic Test Cases

def test_server_string_returns_server():
    # Basic: Exact match for 'server' should return 'server'
    codeflash_output = JobTargetType.get_target_type("server") # 650ns -> 510ns (27.5% faster)

def test_client_string_returns_client():
    # Basic: Exact match for 'client' should return 'client'
    codeflash_output = JobTargetType.get_target_type("client") # 705ns -> 457ns (54.3% faster)

def test_random_string_returns_client():
    # Basic: Any other string should return 'client'
    codeflash_output = JobTargetType.get_target_type("random") # 680ns -> 485ns (40.2% faster)

def test_empty_string_returns_client():
    # Basic: Empty string should return 'client'
    codeflash_output = JobTargetType.get_target_type("") # 550ns -> 397ns (38.5% faster)

def test_server_uppercase_returns_client():
    # Basic: Case sensitivity check; 'SERVER' should return 'client'
    codeflash_output = JobTargetType.get_target_type("SERVER") # 623ns -> 411ns (51.6% faster)

def test_server_with_space_returns_client():
    # Basic: 'server ' (with trailing space) should return 'client'
    codeflash_output = JobTargetType.get_target_type("server ") # 576ns -> 401ns (43.6% faster)

def test_server_with_leading_space_returns_client():
    # Basic: ' server' (with leading space) should return 'client'
    codeflash_output = JobTargetType.get_target_type(" server") # 564ns -> 400ns (41.0% faster)

def test_server_with_embedded_space_returns_client():
    # Basic: 'ser ver' (with embedded space) should return 'client'
    codeflash_output = JobTargetType.get_target_type("ser ver") # 565ns -> 369ns (53.1% faster)

def test_server_with_newline_returns_client():
    # Basic: 'server\n' (with newline) should return 'client'
    codeflash_output = JobTargetType.get_target_type("server\n") # 547ns -> 376ns (45.5% faster)

def test_client_uppercase_returns_client():
    # Basic: 'CLIENT' should return 'client'
    codeflash_output = JobTargetType.get_target_type("CLIENT") # 619ns -> 501ns (23.6% faster)

# Edge Test Cases

def test_none_input_returns_client():
    # Edge: None as input should return 'client'
    codeflash_output = JobTargetType.get_target_type(None) # 702ns -> 472ns (48.7% faster)

def test_integer_input_returns_client():
    # Edge: Integer input should return 'client'
    codeflash_output = JobTargetType.get_target_type(123) # 666ns -> 438ns (52.1% faster)

def test_float_input_returns_client():
    # Edge: Float input should return 'client'
    codeflash_output = JobTargetType.get_target_type(1.23) # 671ns -> 506ns (32.6% faster)

def test_bool_true_input_returns_client():
    # Edge: Boolean True input should return 'client'
    codeflash_output = JobTargetType.get_target_type(True) # 619ns -> 451ns (37.3% faster)

def test_bool_false_input_returns_client():
    # Edge: Boolean False input should return 'client'
    codeflash_output = JobTargetType.get_target_type(False) # 626ns -> 419ns (49.4% faster)

def test_list_input_returns_client():
    # Edge: List input should return 'client'
    codeflash_output = JobTargetType.get_target_type(["server"]) # 616ns -> 410ns (50.2% faster)

def test_dict_input_returns_client():
    # Edge: Dict input should return 'client'
    codeflash_output = JobTargetType.get_target_type({"target": "server"}) # 858ns -> 577ns (48.7% faster)

def test_bytes_input_returns_client():
    # Edge: Bytes input should return 'client'
    codeflash_output = JobTargetType.get_target_type(b"server") # 644ns -> 455ns (41.5% faster)

def test_object_input_returns_client():
    # Edge: Object input should return 'client'
    class Dummy: pass
    codeflash_output = JobTargetType.get_target_type(Dummy()) # 690ns -> 496ns (39.1% faster)

def test_server_with_unicode_returns_client():
    # Edge: Unicode variant should return 'client'
    codeflash_output = JobTargetType.get_target_type("сервер") # 593ns -> 458ns (29.5% faster)

def test_server_with_tab_returns_client():
    # Edge: 'server\t' (with tab) should return 'client'
    codeflash_output = JobTargetType.get_target_type("server\t") # 529ns -> 413ns (28.1% faster)

def test_server_with_multiple_spaces_returns_client():
    # Edge: 'server  ' (multiple trailing spaces) should return 'client'
    codeflash_output = JobTargetType.get_target_type("server  ") # 584ns -> 380ns (53.7% faster)

def test_server_with_special_characters_returns_client():
    # Edge: 'server!' should return 'client'
    codeflash_output = JobTargetType.get_target_type("server!") # 590ns -> 408ns (44.6% faster)

def test_server_with_mixed_case_returns_client():
    # Edge: 'SeRvEr' should return 'client'
    codeflash_output = JobTargetType.get_target_type("SeRvEr") # 660ns -> 463ns (42.5% faster)

def test_server_with_long_string_returns_client():
    # Edge: 'server' followed by many characters should return 'client'
    codeflash_output = JobTargetType.get_target_type("server" + "x" * 100) # 586ns -> 354ns (65.5% faster)

# Large Scale Test Cases

def test_many_random_strings_return_client():
    # Large Scale: 1000 random strings should all return 'client'
    for i in range(1000):
        s = f"random_string_{i}"
        codeflash_output = JobTargetType.get_target_type(s) # 176μs -> 151μs (16.6% faster)

def test_many_server_strings_return_server():
    # Large Scale: 1000 exact 'server' strings should all return 'server'
    for i in range(1000):
        codeflash_output = JobTargetType.get_target_type("server") # 174μs -> 150μs (16.4% faster)

def test_many_client_strings_return_client():
    # Large Scale: 1000 exact 'client' strings should all return 'client'
    for i in range(1000):
        codeflash_output = JobTargetType.get_target_type("client") # 180μs -> 155μs (16.2% faster)

def test_mixed_types_in_large_list():
    # Large Scale: Mix of types in a large list, all should return 'client' except 'server'
    inputs = ["server", "client", None, 123, True, ["server"], {"target": "server"}, b"server"]
    expected = [JobTargetType.SERVER, JobTargetType.CLIENT, JobTargetType.CLIENT, JobTargetType.CLIENT,
                JobTargetType.CLIENT, JobTargetType.CLIENT, JobTargetType.CLIENT, JobTargetType.CLIENT]
    for inp, exp in zip(inputs, expected):
        codeflash_output = JobTargetType.get_target_type(inp) # 2.32μs -> 2.10μs (10.4% faster)

def test_performance_large_unique_inputs():
    # Large Scale: Ensure function handles 1000 unique inputs quickly and correctly
    for i in range(1000):
        s = f"server_{i}"
        codeflash_output = JobTargetType.get_target_type(s) # 176μs -> 151μs (16.5% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import pytest  # used for our unit tests
from nvflare.job_config.defs import JobTargetType

# unit tests

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

def test_get_target_type_server():
    # Test with exact 'server' string
    codeflash_output = JobTargetType.get_target_type("server") # 701ns -> 456ns (53.7% faster)

def test_get_target_type_client():
    # Test with exact 'client' string
    codeflash_output = JobTargetType.get_target_type("client") # 629ns -> 455ns (38.2% faster)

def test_get_target_type_random_string():
    # Test with a random string that is neither 'server' nor 'client'
    codeflash_output = JobTargetType.get_target_type("worker") # 577ns -> 432ns (33.6% faster)

def test_get_target_type_empty_string():
    # Test with empty string
    codeflash_output = JobTargetType.get_target_type("") # 554ns -> 380ns (45.8% faster)

def test_get_target_type_uppercase_server():
    # Test with 'SERVER' in uppercase
    codeflash_output = JobTargetType.get_target_type("SERVER") # 637ns -> 430ns (48.1% faster)

def test_get_target_type_uppercase_client():
    # Test with 'CLIENT' in uppercase
    codeflash_output = JobTargetType.get_target_type("CLIENT") # 616ns -> 410ns (50.2% faster)

def test_get_target_type_mixed_case_server():
    # Test with 'Server' (mixed case)
    codeflash_output = JobTargetType.get_target_type("Server") # 645ns -> 450ns (43.3% faster)

def test_get_target_type_mixed_case_client():
    # Test with 'Client' (mixed case)
    codeflash_output = JobTargetType.get_target_type("Client") # 620ns -> 431ns (43.9% faster)

def test_get_target_type_leading_trailing_whitespace():
    # Test with leading/trailing whitespace
    codeflash_output = JobTargetType.get_target_type(" server") # 595ns -> 437ns (36.2% faster)
    codeflash_output = JobTargetType.get_target_type("server ") # 301ns -> 243ns (23.9% faster)
    codeflash_output = JobTargetType.get_target_type(" client") # 180ns -> 159ns (13.2% faster)
    codeflash_output = JobTargetType.get_target_type("client ") # 184ns -> 151ns (21.9% faster)

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










def test_get_target_type_long_string():
    # Test with a very long string that does not match 'server'
    long_str = "x" * 1000
    codeflash_output = JobTargetType.get_target_type(long_str) # 848ns -> 565ns (50.1% faster)

def test_get_target_type_server_with_unicode():
    # Test with unicode characters around 'server'
    codeflash_output = JobTargetType.get_target_type("服务器") # 675ns -> 423ns (59.6% faster)
    codeflash_output = JobTargetType.get_target_type("server🚀") # 274ns -> 171ns (60.2% faster)
    codeflash_output = JobTargetType.get_target_type("🚀server") # 180ns -> 152ns (18.4% faster)

def test_get_target_type_server_case_sensitive():
    # Test case sensitivity: only exact match returns 'server'
    codeflash_output = JobTargetType.get_target_type("SERVER") # 681ns -> 469ns (45.2% faster)
    codeflash_output = JobTargetType.get_target_type("Server") # 317ns -> 209ns (51.7% faster)
    codeflash_output = JobTargetType.get_target_type("sErVeR") # 187ns -> 157ns (19.1% faster)

def test_get_target_type_server_substring():
    # Test with strings containing 'server' as a substring
    codeflash_output = JobTargetType.get_target_type("myserver") # 563ns -> 404ns (39.4% faster)
    codeflash_output = JobTargetType.get_target_type("server1") # 324ns -> 255ns (27.1% faster)
    codeflash_output = JobTargetType.get_target_type("1server") # 181ns -> 161ns (12.4% faster)

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

def test_get_target_type_many_clients():
    # Test with a large number of non-server strings
    for i in range(1000):
        codeflash_output = JobTargetType.get_target_type(f"client_{i}") # 176μs -> 150μs (17.7% faster)

def test_get_target_type_many_servers():
    # Test with 1000 exact 'server' strings
    for _ in range(1000):
        codeflash_output = JobTargetType.get_target_type("server") # 174μs -> 148μs (17.1% faster)

def test_get_target_type_mixed_large_scale():
    # Test with a mix of 'server', 'client', and random strings
    targets = ["server", "client", "worker", "admin", "server", "client"]
    targets += [f"random_{i}" for i in range(994)]  # total 1000 elements
    expected = ["server", "client", "client", "client", "server", "client"] + ["client"] * 994
    for t, e in zip(targets, expected):
        codeflash_output = JobTargetType.get_target_type(t) # 177μs -> 150μs (18.4% faster)

def test_get_target_type_large_string_edge():
    # Test with a string of maximum reasonable length (999 chars)
    s = "s" * 999
    codeflash_output = JobTargetType.get_target_type(s) # 772ns -> 500ns (54.4% faster)

def test_get_target_type_large_scale_case_sensitive():
    # Test with a large number of 'server' in different cases
    for i in range(500):
        codeflash_output = JobTargetType.get_target_type("server") # 98.1μs -> 85.1μs (15.3% faster)
        codeflash_output = JobTargetType.get_target_type("SERVER")
        codeflash_output = JobTargetType.get_target_type("Server") # 93.5μs -> 84.8μs (10.3% faster)
        codeflash_output = JobTargetType.get_target_type("server ")
        codeflash_output = JobTargetType.get_target_type(" server") # 90.6μs -> 76.5μs (18.4% 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-JobTargetType.get_target_type-mhctutn1 and push.