⚡️ Speed up method bitvavo.parse_order_status by 32%

[codeflash-ai]

📄 32% (0.32x) speedup for bitvavo.parse_order_status in python/ccxt/bitvavo.py

⏱️ Runtime : 325 microseconds → 247 microseconds (best of 50 runs)

📝 Explanation and details

The optimized code achieves a 31% speedup through two key optimizations that eliminate redundant work in performance-critical paths:

1. Dictionary Caching in parse_order_status

• What: Moved the statuses dictionary from being recreated on every method call to a cached static method _statuses_dict()
• Why faster: The original code spent 59.4% of its time (1.41ms out of 2.37ms) in dictionary creation overhead, building the same 13-key dictionary on every call. The optimized version eliminates this entirely, reducing parse_order_status time from 2.37ms to 1.89ms (20% faster)
• Impact: Particularly beneficial for batch processing scenarios - the test with 200 unknown statuses showed 37.3% improvement, and mixed batches showed 39% improvement for unknown statuses

2. Fast-path Dictionary Lookup in safe_string

• What: Added a fast path using dictionary.get(key) for standard dict objects before falling back to the slower Exchange.key_exists() method
• Why faster: dict.get() is a native C operation that's much faster than the key_exists() method which involves attribute checks, exception handling, and type validation. The optimization reduced safe_string time from 695μs to 350μs (50% faster)
• Impact: Since safe_string is called frequently (394 times in the test), this optimization compounds across all lookups

Performance Characteristics:

• Known status lookups: 2-8% faster due to dictionary caching
• Unknown status lookups: 17-39% faster due to both optimizations working together
• Edge cases (non-string inputs, special characters): 20-34% faster, showing the optimizations handle diverse inputs well

These optimizations are especially valuable in high-frequency trading scenarios where order status parsing happens continuously, and the cached dictionary approach scales well with increased call volume.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.bitvavo import bitvavo

# unit tests

@pytest.fixture
def bv():
    # Fixture to provide a fresh bitvavo instance for each test
    return bitvavo()

# 1. Basic Test Cases

def test_parse_order_status_basic_open(bv):
    # Test that 'new' returns 'open'
    codeflash_output = bv.parse_order_status('new') # 2.66μs -> 2.60μs (2.42% faster)

def test_parse_order_status_basic_filled(bv):
    # Test that 'filled' returns 'closed'
    codeflash_output = bv.parse_order_status('filled') # 2.56μs -> 2.49μs (2.90% faster)

def test_parse_order_status_basic_partially_filled(bv):
    # Test that 'partiallyFilled' returns 'open'
    codeflash_output = bv.parse_order_status('partiallyFilled') # 2.57μs -> 2.51μs (2.59% faster)

def test_parse_order_status_basic_canceled(bv):
    # Test that 'canceled' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceled') # 2.57μs -> 2.51μs (2.35% faster)

def test_parse_order_status_basic_expired(bv):
    # Test that 'expired' returns 'canceled'
    codeflash_output = bv.parse_order_status('expired') # 2.52μs -> 2.38μs (5.92% faster)

def test_parse_order_status_basic_rejected(bv):
    # Test that 'rejected' returns 'canceled'
    codeflash_output = bv.parse_order_status('rejected') # 2.56μs -> 2.41μs (6.27% faster)

def test_parse_order_status_basic_awaiting_trigger(bv):
    # Test that 'awaitingTrigger' returns 'open'
    codeflash_output = bv.parse_order_status('awaitingTrigger') # 2.55μs -> 2.37μs (7.38% faster)

# 2. Edge Test Cases

def test_parse_order_status_case_sensitive(bv):
    # Test that 'New' (capitalized) is not recognized and returns itself
    codeflash_output = bv.parse_order_status('New') # 2.66μs -> 2.14μs (24.3% faster)

def test_parse_order_status_unexpected_string(bv):
    # Test that an unknown status returns itself
    codeflash_output = bv.parse_order_status('foobar') # 2.81μs -> 2.15μs (30.8% faster)




def test_parse_order_status_integer_input(bv):
    # Test that an integer input returns itself (converted to string)
    codeflash_output = bv.parse_order_status(123) # 2.53μs -> 2.15μs (17.9% faster)

def test_parse_order_status_boolean_input(bv):
    # Test that boolean input returns itself (converted to string)
    codeflash_output = bv.parse_order_status(True) # 2.82μs -> 2.23μs (26.6% faster)
    codeflash_output = bv.parse_order_status(False) # 1.04μs -> 854ns (21.4% faster)

def test_parse_order_status_statuses_with_similar_names(bv):
    # Test that 'canceledAuction' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledAuction') # 2.54μs -> 2.46μs (3.17% faster)
    # Test that 'canceledSelfTradePrevention' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledSelfTradePrevention') # 1.02μs -> 904ns (12.4% faster)
    # Test that 'canceledIOC' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledIOC') # 865ns -> 675ns (28.1% faster)
    # Test that 'canceledFOK' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledFOK') # 715ns -> 605ns (18.2% faster)
    # Test that 'canceledMarketProtection' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledMarketProtection') # 690ns -> 577ns (19.6% faster)
    # Test that 'canceledPostOnly' returns 'canceled'
    codeflash_output = bv.parse_order_status('canceledPostOnly') # 669ns -> 540ns (23.9% faster)

def test_parse_order_status_statuses_prefixes(bv):
    # Test that a status with a similar but not exact prefix is not mapped
    codeflash_output = bv.parse_order_status('canceledXYZ') # 2.65μs -> 2.11μs (25.6% faster)
    codeflash_output = bv.parse_order_status('cancel') # 1.03μs -> 789ns (30.8% faster)

def test_parse_order_status_statuses_suffixes(bv):
    # Test that a status with a similar but not exact suffix is not mapped
    codeflash_output = bv.parse_order_status('Auctioncanceled') # 2.72μs -> 2.13μs (27.5% faster)

def test_parse_order_status_statuses_whitespace(bv):
    # Test that whitespace is not stripped
    codeflash_output = bv.parse_order_status(' new ') # 2.74μs -> 2.15μs (27.1% faster)

def test_parse_order_status_statuses_with_leading_trailing_spaces(bv):
    # Test that leading/trailing spaces are not ignored
    codeflash_output = bv.parse_order_status(' filled ') # 2.67μs -> 2.17μs (23.2% faster)

def test_parse_order_status_statuses_with_tab_newline(bv):
    # Test that tab and newline are not ignored
    codeflash_output = bv.parse_order_status('\nnew\t') # 2.69μs -> 2.02μs (33.6% faster)

def test_parse_order_status_statuses_with_special_characters(bv):
    # Test that special characters are not mapped
    codeflash_output = bv.parse_order_status('new!') # 2.79μs -> 2.20μs (26.6% faster)

def test_parse_order_status_statuses_with_unicode(bv):
    # Test that unicode characters are not mapped
    codeflash_output = bv.parse_order_status('新しい') # 2.80μs -> 2.21μs (27.0% faster)

# 3. Large Scale Test Cases

def test_parse_order_status_all_known_statuses(bv):
    # Test all known statuses are mapped correctly
    known_statuses = {
        'new': 'open',
        'canceled': 'canceled',
        'canceledAuction': 'canceled',
        'canceledSelfTradePrevention': 'canceled',
        'canceledIOC': 'canceled',
        'canceledFOK': 'canceled',
        'canceledMarketProtection': 'canceled',
        'canceledPostOnly': 'canceled',
        'filled': 'closed',
        'partiallyFilled': 'open',
        'expired': 'canceled',
        'rejected': 'canceled',
        'awaitingTrigger': 'open',
    }
    for k, v in known_statuses.items():
        codeflash_output = bv.parse_order_status(k) # 11.0μs -> 9.24μs (18.6% faster)

def test_parse_order_status_many_random_unknown_statuses(bv):
    # Test a large batch of unknown statuses (should return themselves)
    for i in range(200):
        s = f"unknown_status_{i}"
        codeflash_output = bv.parse_order_status(s) # 153μs -> 111μs (37.3% faster)

def test_parse_order_status_mixed_known_and_unknown_statuses(bv):
    # Test a mix of known and unknown statuses in a batch
    known_statuses = [
        'new', 'canceled', 'filled', 'expired', 'partiallyFilled', 'rejected', 'awaitingTrigger'
    ]
    unknown_statuses = [f"random_{i}" for i in range(100)]
    for s in known_statuses:
        codeflash_output = bv.parse_order_status(s) # 7.34μs -> 6.22μs (18.1% faster)
    for s in unknown_statuses:
        codeflash_output = bv.parse_order_status(s) # 78.6μs -> 56.6μs (39.0% faster)

def test_parse_order_status_large_batch_performance(bv):
    # Test performance and correctness for a large batch (under 1000 elements)
    statuses = (
        ['new', 'canceled', 'filled', 'expired', 'partiallyFilled', 'rejected', 'awaitingTrigger'] * 100 +
        [f"unknown_{i}" for i in range(200)]
    )
    expected = (
        ['open', 'canceled', 'closed', 'canceled', 'open', 'canceled', 'open'] * 100 +
        [f"unknown_{i}" for i in range(200)]
    )
    results = [bv.parse_order_status(s) for s in statuses]

def test_parse_order_status_all_possible_types(bv):
    # Test all possible Python types (should not raise)
    # Only str and None are expected, but test others for robustness
    class Dummy:
        def __str__(self):
            return "dummy"
    inputs = [
        None, 123, 45.6, True, False, '', [], {}, Dummy()
    ]
    expected = [
        None, '123', '45.6', 'True', 'False', '', '[]', '{}', 'dummy'
    ]
    for inp, exp in zip(inputs, expected):
        codeflash_output = bv.parse_order_status(inp)

def test_parse_order_status_batch_with_edge_cases(bv):
    # Test a batch with edge cases: empty, None, known, unknown, numbers, bools
    batch = [
        'new', 'filled', 'expired', 'foobar', '', None, 123, False, 'canceledIOC', 'canceledMarketProtection'
    ]
    expected = [
        'open', 'closed', 'canceled', 'foobar', '', None, '123', 'False', 'canceled', 'canceled'
    ]
    for s, e in zip(batch, expected):
        codeflash_output = bv.parse_order_status(s) # 10.2μs -> 8.24μs (23.3% 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.bitvavo import bitvavo


# Minimal stub for bitvavo with parse_order_status
class BitvavoStub:
    @staticmethod
    def safe_string(dictionary, key, default_value=None):
        return str(dictionary[key]) if key in dictionary and dictionary[key] is not None and dictionary[key] != '' else default_value

    def parse_order_status(self, status):
        statuses = {
            'new': 'open',
            'canceled': 'canceled',
            'canceledAuction': 'canceled',
            'canceledSelfTradePrevention': 'canceled',
            'canceledIOC': 'canceled',
            'canceledFOK': 'canceled',
            'canceledMarketProtection': 'canceled',
            'canceledPostOnly': 'canceled',
            'filled': 'closed',
            'partiallyFilled': 'open',
            'expired': 'canceled',
            'rejected': 'canceled',
            'awaitingTrigger': 'open',
        }
        return self.safe_string(statuses, status, status)
from ccxt.bitvavo import bitvavo

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

To edit these changes git checkout codeflash/optimize-bitvavo.parse_order_status-mhwvtxyq and push.