⚡️ Speed up method bittrade.parse_transaction_status by 56%

[codeflash-ai]

📄 56% (0.56x) speedup for bittrade.parse_transaction_status in python/ccxt/async_support/bittrade.py

⏱️ Runtime : 4.79 milliseconds → 3.06 milliseconds (best of 23 runs)

📝 Explanation and details

The optimization achieves a 56% speedup by eliminating repeated dictionary construction in a hot path.

Key Optimization:
The statuses dictionary in parse_transaction_status() was being recreated on every function call. In the original code, this dictionary construction consumed 56% of the total runtime (21.2ms out of 37.9ms total). The optimized version moves the statuses dictionary to module level as a constant, so it's constructed only once when the module is imported.

Why This Works:

• Dictionary construction cost: Creating a 15-key dictionary repeatedly is expensive in Python due to memory allocation and key hashing overhead
• Hot path impact: With 6,143 function calls in the test, the original code performed 6,143 dictionary constructions vs. just 1 in the optimized version
• Memory efficiency: Reduces object creation from O(n) calls to O(1) constant

Performance Results:

• All test cases show 25-65% improvements in individual call times
• Bulk operations see even higher gains: the 1000-call performance test improved by 64.2%
• The safe_string method performance remains unchanged, confirming the bottleneck was dictionary creation

Workload Impact:
This optimization is particularly beneficial for high-frequency transaction status parsing scenarios, such as processing large batches of transaction data or real-time status updates, where the same function is called repeatedly with different status values.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 6213 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.bittrade import bittrade

# Test suite for bittrade.parse_transaction_status

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

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

def test_status_confirmed(bittrade_instance):
    # Standard deposit status
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed') # 2.98μs -> 2.14μs (39.0% faster)

def test_status_safe(bittrade_instance):
    # Another deposit status mapped to 'ok'
    codeflash_output = bittrade_instance.parse_transaction_status('safe') # 2.83μs -> 2.19μs (29.3% faster)

def test_status_confirming(bittrade_instance):
    # Deposit status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('confirming') # 3.02μs -> 2.09μs (44.3% faster)

def test_status_unknown(bittrade_instance):
    # Deposit status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('unknown') # 2.91μs -> 2.10μs (38.6% faster)

def test_status_orphan(bittrade_instance):
    # Deposit status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('orphan') # 2.90μs -> 2.06μs (41.2% faster)

def test_status_submitted(bittrade_instance):
    # Withdrawal status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('submitted') # 2.77μs -> 2.21μs (25.5% faster)

def test_status_canceled(bittrade_instance):
    # Withdrawal status mapped to 'canceled'
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 2.90μs -> 2.02μs (43.5% faster)

def test_status_reexamine(bittrade_instance):
    # Withdrawal status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('reexamine') # 3.00μs -> 2.06μs (45.1% faster)

def test_status_reject(bittrade_instance):
    # Withdrawal status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('reject') # 2.81μs -> 2.15μs (30.8% faster)

def test_status_pass(bittrade_instance):
    # Withdrawal status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('pass') # 2.87μs -> 2.08μs (37.7% faster)

def test_status_wallet_reject(bittrade_instance):
    # Withdrawal status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-reject') # 3.08μs -> 2.19μs (40.7% faster)

def test_status_confirm_error(bittrade_instance):
    # Withdrawal status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('confirm-error') # 2.92μs -> 2.19μs (33.5% faster)

def test_status_repealed(bittrade_instance):
    # Withdrawal status mapped to 'failed'
    codeflash_output = bittrade_instance.parse_transaction_status('repealed') # 2.81μs -> 2.03μs (38.0% faster)

def test_status_wallet_transfer(bittrade_instance):
    # Withdrawal status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-transfer') # 2.97μs -> 2.14μs (39.0% faster)

def test_status_pre_transfer(bittrade_instance):
    # Withdrawal status mapped to 'pending'
    codeflash_output = bittrade_instance.parse_transaction_status('pre-transfer') # 2.92μs -> 2.11μs (38.1% faster)

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


def test_status_empty_string(bittrade_instance):
    # Empty string should return itself
    codeflash_output = bittrade_instance.parse_transaction_status('') # 3.05μs -> 2.24μs (35.7% faster)

def test_status_none(bittrade_instance):
    # None should return None
    codeflash_output = bittrade_instance.parse_transaction_status(None) # 3.06μs -> 2.24μs (36.9% faster)

def test_status_integer(bittrade_instance):
    # Integer input should return itself as string
    codeflash_output = bittrade_instance.parse_transaction_status(123) # 3.17μs -> 2.18μs (45.2% faster)

def test_status_boolean_true(bittrade_instance):
    # Boolean True input should return itself
    codeflash_output = bittrade_instance.parse_transaction_status(True) # 3.15μs -> 2.24μs (40.9% faster)

def test_status_boolean_false(bittrade_instance):
    # Boolean False input should return itself
    codeflash_output = bittrade_instance.parse_transaction_status(False) # 3.15μs -> 2.26μs (39.6% faster)

def test_status_whitespace(bittrade_instance):
    # Whitespace string should return itself
    codeflash_output = bittrade_instance.parse_transaction_status('   ') # 3.24μs -> 2.28μs (42.3% faster)


def test_status_leading_trailing_spaces(bittrade_instance):
    # Leading/trailing spaces should not match
    codeflash_output = bittrade_instance.parse_transaction_status(' confirmed ') # 3.12μs -> 2.18μs (43.1% faster)

def test_status_similar_but_not_exact(bittrade_instance):
    # Similar but not exact keys should not match
    codeflash_output = bittrade_instance.parse_transaction_status('confirmingg') # 2.98μs -> 2.13μs (39.7% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('wallettransfer') # 1.13μs -> 704ns (59.9% faster)

def test_status_special_characters(bittrade_instance):
    # Status with special characters should return itself
    codeflash_output = bittrade_instance.parse_transaction_status('canceled!') # 2.85μs -> 2.19μs (30.1% faster)

def test_status_unicode(bittrade_instance):
    # Unicode string should return itself
    codeflash_output = bittrade_instance.parse_transaction_status('确认') # 3.10μs -> 2.17μs (42.8% faster)

def test_status_long_string(bittrade_instance):
    # Long string not in mapping should return itself
    long_status = 'a' * 100
    codeflash_output = bittrade_instance.parse_transaction_status(long_status) # 3.00μs -> 2.14μs (40.4% faster)



def test_large_number_of_random_statuses(bittrade_instance):
    # Test performance and correctness with 1000 random statuses
    for i in range(1000):
        status = f'random_status_{i}'
        codeflash_output = bittrade_instance.parse_transaction_status(status) # 793μs -> 511μs (55.0% faster)

def test_large_number_of_known_statuses(bittrade_instance):
    # Test all known statuses repeatedly (100 times each)
    known_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 _ in range(100):
        for status, exp in zip(known_statuses, expected):
            codeflash_output = bittrade_instance.parse_transaction_status(status)

def test_large_scale_mixed_inputs(bittrade_instance):
    # Mix known, unknown, edge, and non-string types in a large batch
    inputs = (
        ['confirmed', 'canceled', 'random', '', None, 42, True, False, 'safe', 'wallet-reject', '   ', 'confirming'] * 50
    )
    expected = (
        ['ok', 'canceled', 'random', '', None, 42, True, False, 'ok', 'failed', '   ', 'pending'] * 50
    )
    for inp, exp in zip(inputs, expected):
        codeflash_output = bittrade_instance.parse_transaction_status(inp) # 463μs -> 300μs (54.1% faster)

def test_performance_under_load(bittrade_instance):
    # Ensure function is fast for 1000 calls (no assertion, just call)
    for i in range(1000):
        bittrade_instance.parse_transaction_status('confirmed') # 727μs -> 443μs (64.2% faster)
        bittrade_instance.parse_transaction_status(f'unknown_status_{i}') # 809μs -> 531μs (52.4% faster)
        bittrade_instance.parse_transaction_status(None) # 786μs -> 510μs (54.1% faster)

# -------------------- MUTATION TESTING GUARDS --------------------

def test_mutation_wrong_mapping(bittrade_instance):
    # If any mapping value is changed, this test will fail
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed') # 2.97μs -> 2.09μs (42.1% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('canceled') # 1.10μs -> 775ns (41.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('reject') # 727ns -> 644ns (12.9% faster)

def test_mutation_missing_key(bittrade_instance):
    # If a mapping key is removed, this test will fail
    codeflash_output = bittrade_instance.parse_transaction_status('wallet-reject') # 2.96μs -> 2.16μs (37.0% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('pre-transfer') # 1.14μs -> 753ns (51.1% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('orphan') # 878ns -> 688ns (27.6% faster)

def test_mutation_extra_key(bittrade_instance):
    # If a new key is added to the mapping, it should not affect unknown status results
    codeflash_output = bittrade_instance.parse_transaction_status('notarealstatus') # 3.17μs -> 2.17μs (46.2% faster)

def test_mutation_case_sensitivity(bittrade_instance):
    # If case-insensitive lookup is introduced, this test will fail
    codeflash_output = bittrade_instance.parse_transaction_status('Confirmed') # 3.06μs -> 2.13μs (43.5% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('confirmed') # 1.37μs -> 997ns (37.8% faster)
    codeflash_output = bittrade_instance.parse_transaction_status('CONFIRMED') # 901ns -> 586ns (53.8% 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.bittrade import bittrade


# Function under test: bittrade.parse_transaction_status
class BittradeMock:
    # This is a simplified version of the Exchange.safe_string method
    @staticmethod
    def safe_string(dictionary, key, default_value=None):
        return str(dictionary[key]) if key in dictionary else default_value

    def parse_transaction_status(self, status):
        statuses = {
            # deposit statuses
            'unknown': 'failed',
            'confirming': 'pending',
            'confirmed': 'ok',
            'safe': 'ok',
            'orphan': 'failed',
            # withdrawal statuses
            'submitted': 'pending',
            'canceled': 'canceled',
            'reexamine': 'pending',
            'reject': 'failed',
            'pass': 'pending',
            'wallet-reject': 'failed',
            # 'confirmed': 'ok',  # present in deposit statuses
            'confirm-error': 'failed',
            'repealed': 'failed',
            'wallet-transfer': 'pending',
            'pre-transfer': 'pending',
        }
        return self.safe_string(statuses, status, status)
from ccxt.async_support.bittrade import bittrade

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

To edit these changes git checkout codeflash/optimize-bittrade.parse_transaction_status-mhyk9aqd and push.