⚡️ Speed up method bittrade.parse_transaction_status by 58%

[codeflash-ai]

📄 58% (0.58x) speedup for bittrade.parse_transaction_status in python/ccxt/bittrade.py

⏱️ Runtime : 3.48 milliseconds → 2.20 milliseconds (best of 14 runs)

📝 Explanation and details

The optimization achieves a 57% speedup through several key changes focused on the most performance-critical bottleneck: the safe_string method.

Primary Optimization - safe_string Method:
The original code called Exchange.key_exists(dictionary, key) which performs multiple checks and exception handling. The optimized version replaces this with direct dictionary operations: key in dictionary and dictionary[key] is not None and dictionary[key] != ''. This eliminates:

• Static method call overhead
• Exception handling in key_exists
• Multiple attribute lookups
• Redundant type checking

Secondary Optimizations in Exchange.__init__:

1. Dictionary merging: Replaced self.deep_extend(current, value) with {**current, **value} for shallow merges, which is significantly faster for simple dictionary combinations
2. Attribute processing: Pre-filtered attribute names with list comprehension to avoid repeated dir() calls and filtering
3. Attribute access: Used getattr() with defaults instead of conditional attribute checks, reducing lookup overhead

Performance Impact by Test Type:

• Valid status lookups (common case): 25-50% faster due to optimized safe_string
• Invalid/unmapped statuses: 60-90% faster because the direct dictionary check fails immediately without calling complex validation logic
• Edge cases (None, empty strings, non-strings): 70-90% faster since the optimized checks handle these efficiently

Real-world Impact:
Since parse_transaction_status is likely called frequently in trading applications for processing transaction updates, this optimization significantly reduces latency in transaction processing pipelines. The optimization is particularly beneficial for applications that process many unmapped or invalid status codes, which see the highest performance gains.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.bittrade import bittrade


# Create a fixture for the bittrade instance
@pytest.fixture
def bittrade_instance():
    return bittrade()

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

def test_confirmed_status_maps_to_ok(bittrade_instance):
    # Typical deposit status
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed') # 3.00μs -> 2.03μs (47.6% faster)

def test_safe_status_maps_to_ok(bittrade_instance):
    # Another deposit status
    codeflash_output = bittrade_instance.parse_transaction_status('safe') # 2.79μs -> 2.01μs (39.1% faster)

def test_orphan_status_maps_to_failed(bittrade_instance):
    # Deposit failed status
    codeflash_output = bittrade_instance.parse_transaction_status('orphan') # 2.78μs -> 2.00μs (39.2% faster)

def test_submitted_status_maps_to_pending(bittrade_instance):
    # Typical withdrawal status
    codeflash_output = bittrade_instance.parse_transaction_status('submitted') # 2.67μs -> 2.05μs (30.3% faster)

def test_canceled_status_maps_to_canceled(bittrade_instance):
    # Withdrawal canceled status
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 2.73μs -> 1.99μs (37.2% faster)

def test_reexamine_status_maps_to_pending(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('reexamine') # 2.77μs -> 1.96μs (41.7% faster)

def test_wallet_reject_status_maps_to_failed(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-reject') # 2.81μs -> 2.23μs (25.9% faster)

def test_wallet_transfer_status_maps_to_pending(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-transfer') # 2.82μs -> 2.19μs (28.9% faster)

def test_pre_transfer_status_maps_to_pending(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('pre-transfer') # 2.98μs -> 2.21μs (35.1% faster)

def test_confirm_error_status_maps_to_failed(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('confirm-error') # 2.92μs -> 2.28μs (27.7% faster)

def test_repealed_status_maps_to_failed(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('repealed') # 2.81μs -> 2.03μs (38.0% faster)

def test_pass_status_maps_to_pending(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('pass') # 2.88μs -> 2.06μs (40.1% faster)

def test_reject_status_maps_to_failed(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('reject') # 2.80μs -> 2.07μs (35.2% faster)

def test_unknown_status_maps_to_failed(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('unknown') # 2.67μs -> 2.04μs (31.1% faster)

def test_confirming_status_maps_to_pending(bittrade_instance):
    codeflash_output = bittrade_instance.parse_transaction_status('confirming') # 2.82μs -> 2.02μs (39.6% faster)

# ------------------- Edge Test Cases -------------------

def test_status_not_in_mapping_returns_input(bittrade_instance):
    # Status not in mapping should return as-is
    codeflash_output = bittrade_instance.parse_transaction_status('foo') # 2.92μs -> 1.63μs (78.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('') # 1.10μs -> 636ns (73.7% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('COMPLETED') # 878ns -> 490ns (79.2% faster)

def test_status_none_returns_none(bittrade_instance):
    # None input should return None
    codeflash_output = bittrade_instance.parse_transaction_status(None) # 2.87μs -> 1.59μs (80.2% faster)

def test_status_integer_input(bittrade_instance):
    # Integer input should return integer as-is (since not in statuses)
    codeflash_output = bittrade_instance.parse_transaction_status(123) # 2.98μs -> 1.75μs (70.0% faster)

def test_status_boolean_input(bittrade_instance):
    # Boolean input should return boolean as-is (since not in statuses)
    codeflash_output = bittrade_instance.parse_transaction_status(True) # 2.97μs -> 1.65μs (79.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status(False) # 1.18μs -> 690ns (70.3% faster)

def test_status_case_sensitivity(bittrade_instance):
    # Mapping is case sensitive, so 'Confirmed' is not mapped
    codeflash_output = bittrade_instance.parse_transaction_status('Confirmed') # 3.00μs -> 1.63μs (83.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('SAFE') # 1.04μs -> 594ns (75.9% faster)

def test_status_with_whitespace(bittrade_instance):
    # Whitespace changes the key, so not mapped
    codeflash_output = bittrade_instance.parse_transaction_status(' confirmed ') # 2.98μs -> 1.67μs (78.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('safe ') # 1.12μs -> 702ns (59.8% faster)

def test_status_with_similar_names(bittrade_instance):
    # Similar but not exact keys are not mapped
    codeflash_output = bittrade_instance.parse_transaction_status('confirm') # 2.88μs -> 1.66μs (73.5% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('wallettransfer') # 1.03μs -> 659ns (56.1% faster)

def test_status_with_unicode(bittrade_instance):
    # Unicode string not in mapping returns as-is
    codeflash_output = bittrade_instance.parse_transaction_status('已完成') # 2.83μs -> 1.56μs (81.3% faster)

def test_status_with_special_characters(bittrade_instance):
    # Special characters not in mapping returns as-is
    codeflash_output = bittrade_instance.parse_transaction_status('@status!') # 2.79μs -> 1.71μs (63.4% faster)

def test_status_with_long_string(bittrade_instance):
    # Very long string not in mapping returns as-is
    long_status = 'a' * 500
    codeflash_output = bittrade_instance.parse_transaction_status(long_status) # 2.81μs -> 1.67μs (68.9% faster)



def test_many_valid_statuses(bittrade_instance):
    # Test all valid statuses in mapping
    all_statuses = [
        'unknown', 'confirming', 'confirmed', 'safe', 'orphan', 'submitted', 'canceled',
        'reexamine', 'reject', 'pass', 'wallet-reject', 'confirm-error', 'repealed',
        'wallet-transfer', 'pre-transfer'
    ]
    expected = [
        'failed', 'pending', 'ok', 'ok', 'failed', 'pending', 'canceled',
        'pending', 'failed', 'pending', 'failed', 'failed', 'failed',
        'pending', 'pending'
    ]
    for s, exp in zip(all_statuses, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(s) # 14.1μs -> 10.4μs (34.9% faster)

def test_large_batch_of_random_statuses(bittrade_instance):
    # Test a large batch of mixed valid and invalid statuses
    valid_statuses = [
        'unknown', 'confirming', 'confirmed', 'safe', 'orphan', 'submitted', 'canceled',
        'reexamine', 'reject', 'pass', 'wallet-reject', 'confirm-error', 'repealed',
        'wallet-transfer', 'pre-transfer'
    ]
    invalid_statuses = ['foo', 'bar', 'baz', '', 'completed', 'pending', 'success', 'error', 'FAILED']
    batch = []
    expected = []
    # Interleave valid and invalid statuses
    for i in range(50):  # total 100 elements
        v = valid_statuses[i % len(valid_statuses)]
        iv = invalid_statuses[i % len(invalid_statuses)]
        batch.append(v)
        batch.append(iv)
        expected.append(bittrade_instance.parse_transaction_status(v)) # 40.0μs -> 30.2μs (32.5% faster)
        expected.append(bittrade_instance.parse_transaction_status(iv)) # 40.6μs -> 23.5μs (72.5% faster)
    # Now test all
    for status, exp in zip(batch, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(status)

def test_large_batch_of_none(bittrade_instance):
    # Test a large batch of None inputs
    for _ in range(100):
        codeflash_output = bittrade_instance.parse_transaction_status(None) # 80.4μs -> 47.6μs (69.0% faster)

def test_large_batch_of_unmapped_strings(bittrade_instance):
    # Test with 100 unique unmapped strings
    for i in range(100):
        s = f"notamappedstatus_{i}"
        codeflash_output = bittrade_instance.parse_transaction_status(s) # 82.4μs -> 50.6μs (63.0% faster)

def test_large_batch_of_mixed_types(bittrade_instance):
    # Test with a batch of mixed types (str, int, float, bool, None, list, dict)
    batch = []
    expected = []
    for i in range(100):
        if i % 7 == 0:
            batch.append(i)
            expected.append(i)
        elif i % 7 == 1:
            batch.append(float(i))
            expected.append(float(i))
        elif i % 7 == 2:
            batch.append(True if i % 2 == 0 else False)
            expected.append(True if i % 2 == 0 else False)
        elif i % 7 == 3:
            batch.append(None)
            expected.append(None)
        elif i % 7 == 4:
            batch.append(['confirmed', 'foo'])
            expected.append(['confirmed', 'foo'])
        elif i % 7 == 5:
            batch.append({'status': 'confirmed'})
            expected.append({'status': 'confirmed'})
        else:
            s = f"unmapped_{i}"
            batch.append(s)
            expected.append(s)
    for status, exp in zip(batch, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(status)

def test_performance_large_unique_statuses(bittrade_instance):
    # Test performance and correctness with 1000 unique unmapped statuses
    # (no assert on speed, but should not crash or be slow)
    for i in range(1000):
        s = f"status_{i}"
        codeflash_output = bittrade_instance.parse_transaction_status(s) # 779μs -> 469μs (66.2% faster)

def test_performance_large_valid_statuses(bittrade_instance):
    # Test with 1000 repetitions of all valid statuses
    valid_statuses = [
        'unknown', 'confirming', 'confirmed', 'safe', 'orphan', 'submitted', 'canceled',
        'reexamine', 'reject', 'pass', 'wallet-reject', 'confirm-error', 'repealed',
        'wallet-transfer', 'pre-transfer'
    ]
    expected = [
        'failed', 'pending', 'ok', 'ok', 'failed', 'pending', 'canceled',
        'pending', 'failed', 'pending', 'failed', 'failed', 'failed',
        'pending', 'pending'
    ]
    for i in range(1000):
        idx = i % len(valid_statuses)
        s = valid_statuses[idx]
        exp = expected[idx]
        codeflash_output = bittrade_instance.parse_transaction_status(s) # 736μs -> 536μs (37.2% 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.bittrade import bittrade

# Test suite for bittrade.parse_transaction_status

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

# 1. Basic Test Cases
def test_basic_known_deposit_statuses(bittrade_instance):
    # Test typical deposit statuses
    codeflash_output = bittrade_instance.parse_transaction_status('unknown') # 3.02μs -> 2.06μs (46.2% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('confirming') # 1.14μs -> 785ns (44.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed') # 793ns -> 593ns (33.7% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('safe') # 679ns -> 544ns (24.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('orphan') # 665ns -> 546ns (21.8% faster)

def test_basic_known_withdrawal_statuses(bittrade_instance):
    # Test typical withdrawal statuses
    codeflash_output = bittrade_instance.parse_transaction_status('submitted') # 3.05μs -> 2.04μs (49.0% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 1.11μs -> 772ns (44.2% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('reexamine') # 947ns -> 555ns (70.6% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('reject') # 736ns -> 765ns (3.79% slower)
    codeflash_output = bittrade_instance.parse_transaction_status('pass') # 670ns -> 533ns (25.7% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-reject') # 769ns -> 671ns (14.6% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('confirm-error') # 813ns -> 732ns (11.1% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('repealed') # 748ns -> 536ns (39.6% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-transfer') # 747ns -> 564ns (32.4% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('pre-transfer') # 772ns -> 540ns (43.0% faster)

def test_basic_unmapped_status_returns_input(bittrade_instance):
    # Statuses not in mapping should return themselves
    codeflash_output = bittrade_instance.parse_transaction_status('completed') # 2.79μs -> 1.56μs (78.1% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('pending') # 1.14μs -> 640ns (77.3% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('ok') # 816ns -> 560ns (45.7% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('failed') # 793ns -> 455ns (74.3% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 1.00μs -> 886ns (13.4% faster)

# 2. Edge Test Cases

def test_edge_case_none_input(bittrade_instance):
    # None as input should return None
    codeflash_output = bittrade_instance.parse_transaction_status(None) # 2.83μs -> 1.74μs (62.7% faster)

def test_edge_case_empty_string(bittrade_instance):
    # Empty string as input should return empty string
    codeflash_output = bittrade_instance.parse_transaction_status('') # 2.92μs -> 1.56μs (86.3% faster)

def test_edge_case_whitespace_string(bittrade_instance):
    # Whitespace is not mapped, so should return itself
    codeflash_output = bittrade_instance.parse_transaction_status(' ') # 2.94μs -> 1.65μs (77.8% faster)

def test_edge_case_case_sensitivity(bittrade_instance):
    # Mapping is case-sensitive, so 'Confirmed' is not mapped
    codeflash_output = bittrade_instance.parse_transaction_status('Confirmed') # 2.95μs -> 1.54μs (91.9% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('CONFIRMING') # 1.29μs -> 752ns (71.5% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 1.14μs -> 952ns (19.2% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('Canceled') # 866ns -> 512ns (69.1% faster)

def test_edge_case_non_string_input(bittrade_instance):
    # Non-string input, such as int, float, bool
    codeflash_output = bittrade_instance.parse_transaction_status(123) # 2.92μs -> 1.70μs (71.1% faster)
    codeflash_output = bittrade_instance.parse_transaction_status(0.0) # 1.49μs -> 1.09μs (37.3% faster)
    codeflash_output = bittrade_instance.parse_transaction_status(True) # 829ns -> 510ns (62.5% faster)
    codeflash_output = bittrade_instance.parse_transaction_status(False) # 758ns -> 489ns (55.0% faster)

def test_edge_case_status_with_special_characters(bittrade_instance):
    # Status with special characters is not mapped
    codeflash_output = bittrade_instance.parse_transaction_status('confirming!') # 2.99μs -> 1.55μs (92.4% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-reject!') # 1.10μs -> 694ns (58.9% faster)

def test_edge_case_status_with_leading_trailing_spaces(bittrade_instance):
    # Leading/trailing spaces are not trimmed, so not mapped
    codeflash_output = bittrade_instance.parse_transaction_status(' confirmed') # 3.03μs -> 1.61μs (88.4% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed ') # 1.19μs -> 611ns (94.8% faster)



def test_edge_case_status_is_tuple(bittrade_instance):
    # Tuples are not valid keys, should return the tuple itself
    t = ('confirmed',)
    codeflash_output = bittrade_instance.parse_transaction_status(t) # 3.15μs -> 1.71μs (84.4% faster)

def test_edge_case_status_is_bytes(bittrade_instance):
    # Bytes are not valid keys, should return bytes itself
    b = b'confirmed'
    codeflash_output = bittrade_instance.parse_transaction_status(b) # 3.25μs -> 1.83μs (77.6% faster)

# 3. Large Scale Test Cases

def test_large_scale_all_mapped_statuses(bittrade_instance):
    # Test all mapped statuses in a batch
    mapped_statuses = [
        'unknown', 'confirming', 'confirmed', 'safe', 'orphan',
        'submitted', 'canceled', 'reexamine', 'reject', 'pass',
        'wallet-reject', 'confirm-error', 'repealed', 'wallet-transfer', 'pre-transfer'
    ]
    expected = [
        'failed', 'pending', 'ok', 'ok', 'failed',
        'pending', 'canceled', 'pending', 'failed', 'pending',
        'failed', 'failed', 'failed', 'pending', 'pending'
    ]
    # Test all at once
    for status, exp in zip(mapped_statuses, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(status) # 13.4μs -> 10.3μs (30.1% faster)

def test_large_scale_many_unmapped_statuses(bittrade_instance):
    # Test with 1000 unique unmapped statuses
    for i in range(1000):
        status = f"unmapped_status_{i}"
        codeflash_output = bittrade_instance.parse_transaction_status(status) # 773μs -> 465μs (66.0% faster)

def test_large_scale_mixed_statuses(bittrade_instance):
    # Mix of mapped and unmapped statuses in a batch
    mapped = ['confirmed', 'canceled', 'wallet-reject']
    unmapped = [f"custom_status_{i}" for i in range(997)]
    statuses = mapped + unmapped
    expected = ['ok', 'canceled', 'failed'] + unmapped
    for status, exp in zip(statuses, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(status) # 781μs -> 470μs (66.0% faster)

def test_large_scale_statuses_with_various_types(bittrade_instance):
    # Test with a mix of types in a batch
    inputs = ['confirmed', None, 42, '', 'unknown', ['confirmed'], {'status': 'confirmed'}, True, False]
    expected = ['ok', None, 42, '', 'failed', ['confirmed'], {'status': 'confirmed'}, True, False]
    for inp, exp in zip(inputs, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(inp)

def test_large_scale_performance_on_large_input_list(bittrade_instance):
    # Ensure function performance is reasonable for a large number of calls
    # (Not a true perf test, but ensures no crash/slowdown for <1000 calls)
    statuses = ['confirmed', 'canceled', 'unknown', 'custom'] * 250  # 1000 elements
    expected = ['ok', 'canceled', 'failed', 'custom'] * 250
    results = [bittrade_instance.parse_transaction_status(s) for s in statuses]
# 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-bittrade.parse_transaction_status-mhx7bnsx and push.