⚡️ Speed up method bittrade.parse_trade by 10%

[codeflash-ai]

📄 10% (0.10x) speedup for bittrade.parse_trade in python/ccxt/bittrade.py

⏱️ Runtime : 2.17 milliseconds → 1.97 milliseconds (best of 43 runs)

📝 Explanation and details

The optimized code achieves a 10% speedup through targeted optimizations of frequently-called methods that handle dictionary access and data conversion - critical operations in cryptocurrency trading data parsing.

Key Performance Optimizations:

1. Dictionary initialization batching: Replaced individual dict() if attr is None else attr checks with a loop over attribute names, reducing repetitive attribute lookups and dictionary creation overhead during Exchange object construction.

2. Direct dictionary access optimization: Rewrote safe_string to use try-catch for dictionary access instead of calling Exchange.key_exists(), eliminating an extra method call and conditional check per access. Added empty string handling for trading data edge cases.

3. Inlined safe_string_2 and safe_integer_2: Eliminated calls to safe_either() helper by implementing the two-key lookup logic directly, avoiding function call overhead and intermediate object creation. These methods are heavily used in trade parsing (called 83+ times per test run).

4. Optimized datetime formatting: In iso8601(), replaced datetime.fromtimestamp() with utcfromtimestamp() and pre-computed milliseconds separately to reduce string slicing operations and improve timestamp conversion performance.

5. Local method references: In safe_trade() and parse_trade(), cached frequently-used methods like self.safe_string as local variables to avoid repeated attribute lookups during trade parsing loops.

6. Precise class optimizations: Simplified scientific notation parsing and reduced temporary object creation in string_mul and string_eq methods.

Impact on Trading Workloads:
These optimizations particularly benefit high-frequency trading scenarios where thousands of trades are parsed rapidly. The test results show consistent 6-14% improvements across various trade parsing scenarios, with the biggest gains on edge cases involving missing fields or complex fee calculations. Since cryptocurrency exchanges process millions of trades daily, these micro-optimizations compound to significant performance improvements in real-world trading applications.

The optimizations maintain full API compatibility while targeting Python's attribute lookup and method call overhead - common bottlenecks in data-intensive financial applications.

✅ Correctness verification report:

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

# ---- unit tests ----

@pytest.fixture
def bt():
    return bittrade()

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

def test_basic_public_trade(bt):
    # Basic public trade parsing
    trade = {
        "amount": 0.010411,
        "trade-id": 102090736910,
        "ts": 1583497692182,
        "id": 10500517034273194594947,
        "price": 9096.05,
        "direction": "sell"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 59.3μs -> 54.3μs (9.22% faster)

def test_basic_private_trade(bt):
    # Basic private trade parsing
    trade = {
        "symbol": "swftcbtc",
        "fee-currency": "swftc",
        "filled-fees": "0.0001",
        "source": "spot-api",
        "id": 83789509854000,
        "type": "buy-limit",
        "order-id": 83711103204909,
        "filled-amount": "45941.53",
        "price": "0.0000001401",
        "created-at": 1597933260729,
        "match-id": 100087455560,
        "role": "maker",
        "trade-id": 100050305348
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 69.4μs -> 63.0μs (10.2% faster)

def test_basic_fee_points(bt):
    # Fee paid in points, not fees
    trade = {
        "symbol": "swftcbtc",
        "fee-currency": "swftc",
        "filled-fees": "0.0",
        "filled-points": "0.005826843283532154",
        "fee-deduct-currency": "ht",
        "filled-amount": "45941.53",
        "price": "0.0000001401",
        "created-at": 1597933260729,
        "type": "sell-market"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 78.5μs -> 71.4μs (9.94% faster)


def test_basic_symbol_market(bt):
    # Symbol parsing with market
    trade = {
        "symbol": "ETH/BTC",
        "price": "0.07",
        "amount": "1.5"
    }
    market = {"symbol": "ETH/BTC"}
    codeflash_output = bt.parse_trade(trade, market=market); result = codeflash_output # 40.9μs -> 39.7μs (3.03% faster)

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

def test_edge_missing_fields(bt):
    # Trade with missing optional fields
    trade = {
        "price": "2.5",
        "amount": "4"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 41.6μs -> 38.3μs (8.62% faster)

def test_edge_zero_amount(bt):
    # Zero amount
    trade = {
        "price": "5.0",
        "amount": "0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 38.7μs -> 36.4μs (6.47% faster)

def test_edge_null_price(bt):
    # Null price
    trade = {
        "price": None,
        "amount": "3.2"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 30.2μs -> 27.4μs (10.2% faster)

def test_edge_null_amount(bt):
    # Null amount
    trade = {
        "price": "1.5",
        "amount": None
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 30.2μs -> 27.7μs (9.23% faster)

def test_edge_fee_missing_currency(bt):
    # Fee present, but currency missing
    trade = {
        "price": "1.0",
        "amount": "2.0",
        "filled-fees": "0.01"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 51.0μs -> 48.5μs (5.10% faster)

def test_edge_fee_zero(bt):
    # Fee explicitly zero
    trade = {
        "price": "1.0",
        "amount": "2.0",
        "filled-fees": "0.0",
        "fee-currency": "usd"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 51.3μs -> 48.0μs (6.93% faster)

def test_edge_type_split_unusual(bt):
    # 'type' field with more than two parts
    trade = {
        "type": "buy-limit-extra",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 40.8μs -> 38.3μs (6.49% faster)

def test_edge_tradeid_vs_id(bt):
    # id missing, trade-id present
    trade = {
        "trade-id": "12345",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 39.8μs -> 37.8μs (5.44% faster)

def test_edge_tradeId_vs_tradeid(bt):
    # tradeId present, trade-id missing
    trade = {
        "tradeId": "54321",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 40.4μs -> 37.7μs (7.01% faster)

def test_edge_fee_points_and_fees(bt):
    # Both filled-points and filled-fees present, filled-fees is nonzero
    trade = {
        "filled-fees": "0.02",
        "filled-points": "0.03",
        "fee-currency": "btc",
        "fee-deduct-currency": "eth",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 56.7μs -> 53.2μs (6.66% faster)

def test_edge_fee_points_and_fees_zero(bt):
    # Both filled-points and filled-fees present, filled-fees is zero
    trade = {
        "filled-fees": "0.0",
        "filled-points": "0.03",
        "fee-currency": "btc",
        "fee-deduct-currency": "eth",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 59.4μs -> 54.7μs (8.51% faster)

def test_edge_symbol_case(bt):
    # Symbol case normalization
    trade = {
        "symbol": "xbtusd",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 40.2μs -> 37.8μs (6.27% faster)

def test_edge_symbol_with_slash(bt):
    # Symbol with slash
    trade = {
        "symbol": "BTC/USD",
        "price": "1.0",
        "amount": "2.0"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 40.7μs -> 37.8μs (7.59% faster)

def test_edge_iso8601(bt):
    # ISO8601 datetime conversion
    trade = {
        "price": "1.0",
        "amount": "2.0",
        "ts": 1600000000000
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 57.3μs -> 52.3μs (9.50% faster)

def test_edge_invalid_timestamp(bt):
    # Invalid timestamp
    trade = {
        "price": "1.0",
        "amount": "2.0",
        "ts": "not_a_timestamp"
    }
    codeflash_output = bt.parse_trade(trade); result = codeflash_output # 41.7μs -> 38.9μs (7.04% faster)

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

def test_large_scale_many_trades(bt):
    # Many trades, check for performance and correctness
    trades = []
    for i in range(500):  # Reasonable size
        trades.append({
            "symbol": "BTC/USD",
            "price": str(10000 + i),
            "amount": str(0.1 + i * 0.01),
            "id": str(i),
            "ts": 1600000000000 + i * 1000
        })
    results = [bt.parse_trade(trade) for trade in trades]
    for i, result in enumerate(results):
        pass

def test_large_scale_varied_symbols(bt):
    # Large set of trades with varied symbols
    symbols = ["BTC/USD", "ETH/BTC", "XRP/USDT", "LTC/EUR"]
    trades = []
    for i in range(250):
        s = symbols[i % len(symbols)]
        trades.append({
            "symbol": s,
            "price": str(100 + i),
            "amount": str(1 + i * 0.1),
            "id": str(i)
        })
    results = [bt.parse_trade(trade) for trade in trades]
    for i, result in enumerate(results):
        pass

def test_large_scale_fee_points(bt):
    # Large set of trades with filled-points fee
    trades = []
    for i in range(100):
        trades.append({
            "symbol": "BTC/USD",
            "price": "10000",
            "amount": "1",
            "filled-fees": "0.0",
            "filled-points": str(i * 0.01),
            "fee-deduct-currency": "eth"
        })
    results = [bt.parse_trade(trade) for trade in trades]
    for i, result in enumerate(results):
        pass

def test_large_scale_missing_fields(bt):
    # Large set of trades with missing fields
    trades = []
    for i in range(100):
        trades.append({
            "price": str(i),
            "amount": str(i * 2)
        })
    results = [bt.parse_trade(trade) for trade in trades]
    for i, result in enumerate(results):
        pass

def test_large_scale_fee_currency_mapping(bt):
    # Fee currency mapping for XBT/BCC/BCHSV
    trades = [
        {"price": "1", "amount": "1", "filled-fees": "0.1", "fee-currency": "XBT"},
        {"price": "1", "amount": "1", "filled-fees": "0.2", "fee-currency": "BCC"},
        {"price": "1", "amount": "1", "filled-fees": "0.3", "fee-currency": "BCHSV"},
    ]
    results = [bt.parse_trade(trade) for trade in trades]
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import copy
import time

# imports
import pytest
from ccxt.bittrade import bittrade

# function to test
# (Assume all imports and classes above are available, as per your provided code.)

# Import the bittrade class (normally from ccxt.bittrade import bittrade, but here we define inline)
# We'll instantiate bittrade and call its parse_trade method in our tests.

# ---------------------
# UNIT TESTS FOR bittrade.parse_trade
# ---------------------

@pytest.fixture
def bittrade_instance():
    return bittrade()

# ---------------------
# 1. BASIC TEST CASES
# ---------------------

def test_parse_trade_public_basic(bittrade_instance):
    # Typical public trade with required fields
    trade = {
        "amount": 0.010411,
        "trade-id": 102090736910,
        "ts": 1583497692182,
        "id": 10500517034273194594947,
        "price": 9096.05,
        "direction": "sell"
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 63.2μs -> 56.8μs (11.2% faster)

def test_parse_trade_private_basic(bittrade_instance):
    # Typical private trade with all fields
    trade = {
        "symbol": "swftcbtc",
        "fee-currency": "swftc",
        "filled-fees": "0.1",
        "source": "spot-api",
        "id": 83789509854000,
        "type": "buy-limit",
        "order-id": 83711103204909,
        'filled-points': "0.005826843283532154",
        "fee-deduct-currency": "ht",
        'filled-amount': "45941.53",
        "price": "0.0000001401",
        "created-at": 1597933260729,
        "match-id": 100087455560,
        "role": "maker",
        "trade-id": 100050305348
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 74.7μs -> 67.4μs (10.8% faster)

def test_parse_trade_type_and_side_from_type_field(bittrade_instance):
    # 'type' field should override 'direction' and split into side/type
    trade = {
        "type": "sell-market",
        "direction": "buy",  # should be ignored
        "price": "100",
        "amount": "2",
        "ts": 1234567890
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 57.0μs -> 50.9μs (12.1% faster)

def test_parse_trade_fee_filled_points(bittrade_instance):
    # If filled-points is present and filled-fees is None or 0, fee should use filled-points and fee-deduct-currency
    trade = {
        "fee-currency": "swftc",
        "filled-fees": "0.0",
        "filled-points": "0.005",
        "fee-deduct-currency": "ht",
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 74.0μs -> 66.7μs (10.9% faster)

def test_parse_trade_fee_none_fields(bittrade_instance):
    # No fee fields at all
    trade = {
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.6μs -> 47.4μs (13.0% faster)

def test_parse_trade_fee_filled_fees_only(bittrade_instance):
    # Only filled-fees is present
    trade = {
        "filled-fees": "0.123",
        "fee-currency": "btc",
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 64.6μs -> 58.5μs (10.4% faster)

def test_parse_trade_id_fallback(bittrade_instance):
    # id should fall back to trade-id if 'id' is missing
    trade = {
        "trade-id": "abc123",
        "ts": 1,
        "price": "1",
        "amount": "1"
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.4μs -> 47.2μs (13.2% faster)

def test_parse_trade_id_priority(bittrade_instance):
    # id should use 'id' if present, not 'trade-id'
    trade = {
        "id": "mainid",
        "trade-id": "fallbackid",
        "ts": 1,
        "price": "1",
        "amount": "1"
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.3μs -> 46.9μs (13.6% faster)

def test_parse_trade_symbol_from_market(bittrade_instance):
    # If 'symbol' is missing, but market is provided, use market['symbol']
    trade = {
        "price": "1",
        "amount": "1",
        "ts": 1,
    }
    market = {"symbol": "BTC/USDT"}
    codeflash_output = bittrade_instance.parse_trade(trade, market); parsed = codeflash_output # 52.8μs -> 47.0μs (12.2% faster)

# ---------------------
# 2. EDGE TEST CASES
# ---------------------

def test_parse_trade_missing_fields(bittrade_instance):
    # All optional fields missing
    trade = {}
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 28.9μs -> 26.0μs (10.8% faster)

def test_parse_trade_zero_amount_and_price(bittrade_instance):
    # Zero amount and price should yield cost 0
    trade = {
        "price": "0",
        "amount": "0",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 54.4μs -> 48.3μs (12.7% faster)

def test_parse_trade_negative_amount_and_price(bittrade_instance):
    # Negative values (should multiply as usual)
    trade = {
        "price": "-5",
        "amount": "-2",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 55.9μs -> 49.6μs (12.8% faster)

def test_parse_trade_unusual_types(bittrade_instance):
    # Non-string, non-float types
    trade = {
        "price": 3,
        "amount": 2,
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.3μs -> 47.4μs (12.5% faster)

def test_parse_trade_string_numbers_with_exponents(bittrade_instance):
    # Exponent notation in price/amount
    trade = {
        "price": "1e2",
        "amount": "2e-2",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 54.6μs -> 48.5μs (12.7% faster)


def test_parse_trade_fee_currency_case_insensitive(bittrade_instance):
    # fee-currency should be uppercased
    trade = {
        "filled-fees": "1.23",
        "fee-currency": "eth",
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 69.6μs -> 61.4μs (13.3% faster)

def test_parse_trade_fee_deduct_currency_case_insensitive(bittrade_instance):
    # fee-deduct-currency should be uppercased if used
    trade = {
        "filled-fees": "0.0",
        "filled-points": "1.23",
        "fee-deduct-currency": "usdt",
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 73.9μs -> 66.1μs (11.7% faster)

def test_parse_trade_tradeid_variants(bittrade_instance):
    # Should use 'tradeId' if present
    trade = {
        "tradeId": "xyz",
        "ts": 1,
        "price": "1",
        "amount": "1"
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.7μs -> 47.8μs (12.2% faster)


def test_parse_trade_large_numbers(bittrade_instance):
    # Large numbers should not overflow
    trade = {
        "price": "1e18",
        "amount": "1e10",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 58.2μs -> 51.2μs (13.7% faster)

def test_parse_trade_small_numbers(bittrade_instance):
    # Small numbers should be handled
    trade = {
        "price": "1e-18",
        "amount": "1e-10",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 56.0μs -> 49.1μs (14.2% faster)

def test_parse_trade_symbol_case_and_delimiter(bittrade_instance):
    # symbol should be uppercased and delimiter handled if present
    trade = {
        "symbol": "ethusdt",
        "price": "1",
        "amount": "1",
        "ts": 1
    }
    codeflash_output = bittrade_instance.parse_trade(trade); parsed = codeflash_output # 53.8μs -> 47.4μs (13.5% faster)

# ---------------------
# 3. LARGE SCALE TEST CASES
# ---------------------

def test_parse_trade_bulk_trades_performance(bittrade_instance):
    # Parse 1000 trades in a loop, ensure all parse correctly and quickly
    trades = []
    n = 1000
    for i in range(n):
        trades.append({
            "symbol": "btcusdt",
            "price": str(10000 + i),
            "amount": str(0.001 * (i+1)),
            "ts": 1600000000000 + i,
            "trade-id": str(i),
            "order-id": str(i*10),
            "direction": "buy" if i % 2 == 0 else "sell",
            "type": "buy-limit" if i % 2 == 0 else "sell-market",
            "filled-fees": str(0.01 * i),
            "fee-currency": "btc",
            "role": "maker" if i % 3 == 0 else "taker"
        })
    start = time.time()
    results = [bittrade_instance.parse_trade(trade) for trade in trades]
    end = time.time()
    for i, parsed in enumerate(results):
        # type/side split
        if i % 2 == 0:
            pass
        else:
            pass

def test_parse_trade_bulk_edge_cases(bittrade_instance):
    # Parse 500 trades with missing and malformed fields
    n = 500
    trades = []
    for i in range(n):
        trade = {}
        if i % 5 == 0:
            trade['price'] = "notanumber"
        else:
            trade['price'] = str(i)
        if i % 7 == 0:
            trade['amount'] = None
        else:
            trade['amount'] = str(i*0.1)
        if i % 10 == 0:
            trade['filled-fees'] = "0"
            trade['filled-points'] = "0.1"
            trade['fee-deduct-currency'] = "usdt"
        trades.append(trade)
    results = [bittrade_instance.parse_trade(trade) for trade in trades] # 44.1μs -> 41.4μs (6.50% faster)
    for i, parsed in enumerate(results):
        if i % 5 == 0 or i % 7 == 0:
            pass
        else:
            pass
        if i % 10 == 0:
            pass
        else:
            pass

def test_parse_trade_bulk_varied_types(bittrade_instance):
    # Parse 100 trades with mixed types for price/amount
    n = 100
    trades = []
    for i in range(n):
        trade = {
            "price": i if i % 2 == 0 else str(i),
            "amount": float(i) if i % 3 == 0 else str(i),
            "ts": 1
        }
        if i % 4 == 0:
            trade["filled-fees"] = str(i * 0.01)
            trade["fee-currency"] = "btc"
    results = [bittrade_instance.parse_trade(trade) for trade in trades] # 58.3μs -> 51.5μs (13.1% faster)
    for i, parsed in enumerate(results):
        # price and amount should always parse to numbers or None
        if i % 3 == 0:
            expected_amount = float(i)
        else:
            expected_amount = float(i)
        if i % 2 == 0:
            expected_price = float(i)
        else:
            expected_price = float(i)
        if i % 4 == 0:
            pass
        else:
            pass
# 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_trade-mhx1j368 and push.