⚡️ Speed up method hyperliquid.parse_order_status by 28%

[codeflash-ai]

📄 28% (0.28x) speedup for hyperliquid.parse_order_status in python/ccxt/async_support/hyperliquid.py

⏱️ Runtime : 2.70 milliseconds → 2.11 milliseconds (best of 26 runs)

📝 Explanation and details

The optimized code achieves a 27% speedup through two key optimizations in the parse_order_status method:

1. Moved Dictionary to Module Level
The statuses dictionary is now defined as a module-level constant _HYPERLIQUID_STATUSES instead of being recreated on every function call. This eliminates the overhead of dictionary allocation and initialization, which the line profiler shows was consuming ~25% of the original function's time across 6 dictionary assignments.

2. Reordered Suffix Checks for Better Branch Prediction
The order of endswith() checks was swapped to check 'Canceled' before 'Rejected'. Based on the profiler data, this change is particularly effective because:

• 'Canceled' suffixes appear more frequently in typical workloads (1,233 hits vs 1,117 'Rejected' hits)
• Early exit on the more common case reduces total string operations

Performance Impact Analysis:
The test results show the optimization is most effective for:

• Suffix matching cases: Up to 89% faster for 'Canceled' suffixes, 46% faster for 'Rejected' suffixes
• Dictionary lookups: 10-20% faster for standard status mappings like 'marginCanceled'
• Large-scale processing: 22-85% faster when processing batches of status strings

The optimizations preserve exact behavior while reducing CPU overhead through better memory allocation patterns and more efficient control flow. This is particularly beneficial in trading systems where order status parsing happens frequently in hot paths.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.async_support.hyperliquid import hyperliquid


# Create a fixture for the class
@pytest.fixture
def hl():
    return hyperliquid()

# -------------------- BASIC TEST CASES --------------------

def test_basic_status_open(hl):
    # Standard "open" status
    codeflash_output = hl.parse_order_status("open") # 2.75μs -> 2.59μs (6.26% faster)

def test_basic_status_filled(hl):
    # Standard "filled" status
    codeflash_output = hl.parse_order_status("filled") # 2.54μs -> 2.43μs (4.73% faster)

def test_basic_status_canceled(hl):
    # Standard "canceled" status
    codeflash_output = hl.parse_order_status("canceled") # 2.71μs -> 2.46μs (10.4% faster)

def test_basic_status_rejected(hl):
    # Standard "rejected" status
    codeflash_output = hl.parse_order_status("rejected") # 2.53μs -> 2.47μs (2.55% faster)

def test_basic_status_triggered(hl):
    # Standard "triggered" status
    codeflash_output = hl.parse_order_status("triggered") # 2.63μs -> 2.49μs (5.45% faster)

def test_basic_status_margin_canceled(hl):
    # Standard "marginCanceled" status
    codeflash_output = hl.parse_order_status("marginCanceled") # 1.37μs -> 953ns (43.5% faster)

# -------------------- EDGE TEST CASES --------------------

def test_edge_status_none(hl):
    # None input should return None
    codeflash_output = hl.parse_order_status(None) # 469ns -> 545ns (13.9% slower)

def test_edge_status_empty_string(hl):
    # Empty string should return empty string (not mapped, so returns as is)
    codeflash_output = hl.parse_order_status("") # 2.61μs -> 2.66μs (2.14% slower)

def test_edge_status_case_sensitive(hl):
    # Status is case sensitive; "Filled" should not match "filled"
    codeflash_output = hl.parse_order_status("Filled") # 2.82μs -> 2.54μs (10.9% faster)
    # "CANCELED" should not match "canceled"
    codeflash_output = hl.parse_order_status("CANCELED") # 1.09μs -> 1.09μs (0.457% slower)

def test_edge_status_suffix_rejected(hl):
    # Suffix "Rejected" should map to "rejected"
    codeflash_output = hl.parse_order_status("limitRejected") # 1.28μs -> 1.06μs (21.1% faster)
    codeflash_output = hl.parse_order_status("marketRejected") # 464ns -> 317ns (46.4% faster)
    # Should not match if not at the end
    codeflash_output = hl.parse_order_status("RejectedOrder") # 1.94μs -> 1.91μs (1.36% faster)

def test_edge_status_suffix_canceled(hl):
    # Suffix "Canceled" should map to "canceled"
    codeflash_output = hl.parse_order_status("limitCanceled") # 1.34μs -> 903ns (48.7% faster)
    codeflash_output = hl.parse_order_status("marketCanceled") # 520ns -> 279ns (86.4% faster)
    # Should not match if not at the end
    codeflash_output = hl.parse_order_status("CanceledOrder") # 1.83μs -> 1.88μs (2.39% slower)


def test_edge_status_unmapped_string(hl):
    # Unmapped string should return as is
    codeflash_output = hl.parse_order_status("pending") # 3.04μs -> 2.69μs (13.0% faster)
    codeflash_output = hl.parse_order_status("unknownStatus") # 1.20μs -> 1.02μs (16.9% faster)

def test_edge_status_partial_suffix(hl):
    # "Rejected" and "Canceled" must be at the end
    codeflash_output = hl.parse_order_status("XRejectedX") # 2.73μs -> 2.56μs (6.61% faster)
    codeflash_output = hl.parse_order_status("XCanceledX") # 1.11μs -> 965ns (14.9% faster)

def test_edge_status_similar_but_not_exact(hl):
    # "cancelled" (double 'l') is not mapped
    codeflash_output = hl.parse_order_status("cancelled") # 2.84μs -> 2.43μs (16.7% faster)
    # "rejection" is not mapped
    codeflash_output = hl.parse_order_status("rejection") # 1.07μs -> 932ns (14.5% faster)

# -------------------- LARGE SCALE TEST CASES --------------------

def test_large_scale_many_statuses(hl):
    # Test a large number of unique unmapped statuses
    for i in range(1000):
        status = f"customStatus{i}"
        codeflash_output = hl.parse_order_status(status) # 711μs -> 581μs (22.2% faster)

def test_large_scale_suffix_canceled_and_rejected(hl):
    # Test 500 statuses ending with "Canceled" and 500 with "Rejected"
    for i in range(500):
        status = f"test{i}Canceled"
        codeflash_output = hl.parse_order_status(status) # 170μs -> 91.9μs (85.8% faster)
    for i in range(500):
        status = f"test{i}Rejected"
        codeflash_output = hl.parse_order_status(status) # 143μs -> 111μs (27.9% faster)

def test_large_scale_mixed_types(hl):
    # Test a mix of types in a large batch
    inputs = (
        ["filled", "open", "canceled", "triggered", "rejected", "marginCanceled"] +
        [f"otherStatus{i}" for i in range(100)] +
        [i for i in range(100)] +
        [None, "", True, False, 1.23, ["filled"], {"status": "open"}]
    )
    expected = (
        ["closed", "open", "canceled", "open", "rejected", "canceled"] +
        [f"otherStatus{i}" for i in range(100)] +
        [i for i in range(100)] +
        [None, "", True, False, 1.23, ["filled"], {"status": "open"}]
    )
    for inp, exp in zip(inputs, expected):
        codeflash_output = hl.parse_order_status(inp)

def test_large_scale_performance(hl):
    # This test is to ensure the function can handle a large batch efficiently
    # (not a strict performance test, but should not hang or crash)
    statuses = ["filled", "open", "canceled", "triggered", "rejected", "marginCanceled"] * 150
    expected = ["closed", "open", "canceled", "open", "rejected", "canceled"] * 150
    results = [hl.parse_order_status(s) for s in statuses]

# -------------------- ADDITIONAL EDGE CASES --------------------

def test_edge_status_whitespace(hl):
    # Whitespace should not be stripped, so " filled " is not mapped
    codeflash_output = hl.parse_order_status(" filled ") # 2.94μs -> 2.66μs (10.6% faster)
    # Tabs and newlines
    codeflash_output = hl.parse_order_status("\nopen\t") # 1.09μs -> 990ns (10.3% faster)

def test_edge_status_numeric_string(hl):
    # Numeric string is not mapped, should return as is
    codeflash_output = hl.parse_order_status("123") # 2.78μs -> 2.62μs (6.15% faster)

def test_edge_status_special_characters(hl):
    # Special characters in status
    codeflash_output = hl.parse_order_status("filled!") # 2.69μs -> 2.55μs (5.85% faster)
    codeflash_output = hl.parse_order_status("rejected#") # 1.08μs -> 961ns (12.2% faster)
    codeflash_output = hl.parse_order_status("open?") # 824ns -> 736ns (12.0% faster)

def test_edge_status_unicode(hl):
    # Unicode characters in status
    codeflash_output = hl.parse_order_status("已完成") # 2.75μs -> 2.53μs (8.37% faster)
    codeflash_output = hl.parse_order_status("отклонено") # 1.07μs -> 998ns (6.81% faster)

def test_edge_status_long_string(hl):
    # Very long status string, unmapped
    long_status = "x" * 500
    codeflash_output = hl.parse_order_status(long_status) # 2.77μs -> 2.54μs (8.93% 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
from ccxt.async_support.hyperliquid import hyperliquid

# Instantiate the class once for all tests
hl = hyperliquid()

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

def test_status_none_returns_none():
    # Test None input returns None
    codeflash_output = hl.parse_order_status(None) # 423ns -> 406ns (4.19% faster)

def test_status_filled_returns_closed():
    # Test 'filled' maps to 'closed'
    codeflash_output = hl.parse_order_status('filled') # 2.46μs -> 2.40μs (2.67% faster)

def test_status_open_returns_open():
    # Test 'open' maps to 'open'
    codeflash_output = hl.parse_order_status('open') # 2.16μs -> 1.97μs (9.28% faster)

def test_status_canceled_returns_canceled():
    # Test 'canceled' maps to 'canceled'
    codeflash_output = hl.parse_order_status('canceled') # 2.08μs -> 2.14μs (2.52% slower)

def test_status_rejected_returns_rejected():
    # Test 'rejected' maps to 'rejected'
    codeflash_output = hl.parse_order_status('rejected') # 2.04μs -> 2.00μs (1.70% faster)

def test_status_marginCanceled_returns_canceled():
    # Test 'marginCanceled' maps to 'canceled'
    codeflash_output = hl.parse_order_status('marginCanceled') # 975ns -> 640ns (52.3% faster)

def test_status_triggered_returns_open():
    # Test 'triggered' maps to 'open'
    codeflash_output = hl.parse_order_status('triggered') # 2.16μs -> 2.10μs (2.47% faster)

def test_status_unknown_returns_input():
    # Test unknown status returns input as-is
    codeflash_output = hl.parse_order_status('pending') # 2.22μs -> 2.12μs (4.92% faster)

def test_status_empty_string_returns_empty_string():
    # Test empty string returns empty string
    codeflash_output = hl.parse_order_status('') # 2.21μs -> 1.98μs (11.8% faster)



def test_status_endswith_rejected_suffix():
    # Test status ending with 'Rejected' returns 'rejected'
    codeflash_output = hl.parse_order_status('limitRejected') # 1.20μs -> 947ns (26.7% faster)
    codeflash_output = hl.parse_order_status('marketRejected') # 430ns -> 365ns (17.8% faster)
    codeflash_output = hl.parse_order_status('fooRejected') # 338ns -> 247ns (36.8% faster)

def test_status_endswith_canceled_suffix():
    # Test status ending with 'Canceled' returns 'canceled'
    codeflash_output = hl.parse_order_status('limitCanceled') # 1.05μs -> 621ns (68.9% faster)
    codeflash_output = hl.parse_order_status('marketCanceled') # 511ns -> 240ns (113% faster)
    codeflash_output = hl.parse_order_status('fooCanceled') # 352ns -> 186ns (89.2% faster)

def test_status_case_sensitivity():
    # Test case sensitivity: should not match if casing is different
    codeflash_output = hl.parse_order_status('Filled') # 3.19μs -> 2.90μs (9.90% faster)
    codeflash_output = hl.parse_order_status('CANCELED') # 1.20μs -> 1.09μs (9.62% faster)
    codeflash_output = hl.parse_order_status('REJECTED') # 1.01μs -> 800ns (26.9% faster)
    codeflash_output = hl.parse_order_status('MarginCanceled') # 434ns -> 259ns (67.6% faster)


def test_status_whitespace():
    # Test status with leading/trailing whitespace is not matched
    codeflash_output = hl.parse_order_status(' filled ') # 3.52μs -> 3.04μs (15.7% faster)
    codeflash_output = hl.parse_order_status('open ') # 1.23μs -> 1.09μs (13.0% faster)
    codeflash_output = hl.parse_order_status(' canceled') # 900ns -> 814ns (10.6% faster)

def test_status_partial_suffix():
    # Test status containing but not ending with 'Rejected'/'Canceled'
    codeflash_output = hl.parse_order_status('RejectedLimit') # 2.21μs -> 2.04μs (8.34% faster)
    codeflash_output = hl.parse_order_status('CanceledMarket') # 974ns -> 849ns (14.7% faster)

def test_status_long_string():
    # Test a very long string with a matching suffix
    status = 'x' * 100 + 'Rejected'
    codeflash_output = hl.parse_order_status(status) # 894ns -> 697ns (28.3% faster)
    status2 = 'y' * 100 + 'Canceled'
    codeflash_output = hl.parse_order_status(status2) # 532ns -> 254ns (109% faster)

def test_status_long_string_no_suffix():
    # Test a very long string with no matching suffix
    status = 'x' * 100 + 'Active'
    codeflash_output = hl.parse_order_status(status) # 2.24μs -> 2.08μs (7.24% faster)



def test_large_list_of_statuses():
    # Test with a large list of statuses (up to 1000 elements)
    statuses = ['filled', 'open', 'canceled', 'rejected', 'marginCanceled', 'triggered', 'pending', 'limitRejected', 'limitCanceled']
    expected = ['closed', 'open', 'canceled', 'rejected', 'canceled', 'open', 'pending', 'rejected', 'canceled']
    # Repeat pattern to reach 1000 elements
    large_statuses = statuses * (1000 // len(statuses))
    large_expected = expected * (1000 // len(expected))
    # Test all outputs are correct
    for s, e in zip(large_statuses, large_expected):
        codeflash_output = hl.parse_order_status(s) # 563μs -> 445μs (26.4% faster)

def test_large_unique_statuses():
    # Test with 1000 unique statuses, only a few should match known statuses
    known_statuses = {'filled': 'closed', 'open': 'open', 'canceled': 'canceled', 'rejected': 'rejected', 'marginCanceled': 'canceled', 'triggered': 'open'}
    statuses = []
    expected = []
    for i in range(1000):
        if i % 100 == 0:
            # Insert a known status every 100 elements
            k = list(known_statuses.keys())[i // 100 % len(known_statuses)]
            statuses.append(k)
            expected.append(known_statuses[k])
        else:
            s = f'status_{i}'
            statuses.append(s)
            expected.append(s)
    for s, e in zip(statuses, expected):
        codeflash_output = hl.parse_order_status(s) # 698μs -> 588μs (18.7% faster)

def test_large_suffix_statuses():
    # Test with a large number of statuses ending with 'Rejected' or 'Canceled'
    statuses = []
    expected = []
    for i in range(500):
        statuses.append(f'foo{i}Rejected')
        expected.append('rejected')
    for i in range(500):
        statuses.append(f'bar{i}Canceled')
        expected.append('canceled')
    for s, e in zip(statuses, expected):
        codeflash_output = hl.parse_order_status(s) # 310μs -> 203μs (52.5% faster)

To edit these changes git checkout codeflash/optimize-hyperliquid.parse_order_status-mhzy4fn3 and push.