⚡️ Speed up method bitteam.parse_trade by 7%

[codeflash-ai]

📄 7% (0.07x) speedup for bitteam.parse_trade in python/ccxt/bitteam.py

⏱️ Runtime : 1.77 milliseconds → 1.65 milliseconds (best of 10 runs)

📝 Explanation and details

The optimized code achieves a 7% speedup through several targeted improvements in frequently-called utility methods within the CCXT exchange library:

Key Optimizations:

1. Streamlined dict initialization - Replaced 13 repetitive getattr/setattr calls with a loop over attribute names, reducing overhead during Exchange object construction.

2. Faster safe_string/safe_value methods - Eliminated the expensive key_exists() helper method that performed redundant type checks. The optimized version uses direct dictionary access with try/catch exception handling, which is significantly faster in Python for the common case where keys exist.

3. Optimized ISO8601 formatting - Replaced string slicing and multiple formatting operations (strftime + string manipulation + format) with a single f-string expression. This eliminates intermediate string objects and reduces formatting overhead.

4. Fast-path for parse_to_int - Added early returns for int/float inputs to avoid unnecessary string conversion and parsing when the input is already numeric.

5. Improved safe_string_2 - Simplified the helper chain by removing the safe_either wrapper and implementing the fallback logic directly, reducing function call overhead.

Performance Impact:
The optimizations particularly benefit workloads with frequent trade parsing, as evidenced by the test results showing 5-11% improvements across various trade parsing scenarios. The safe_string method showed the most dramatic improvement (26% reduction in execution time) as it's called extensively during data extraction from API responses.

Test Case Benefits:
The optimizations are most effective for:

• High-frequency trade parsing (large batch tests show consistent gains)
• Mixed field scenarios where some data may be missing (optimized safe_* methods handle None/missing values more efficiently)
• Real-time trading applications where microsecond improvements in parsing can compound significantly

These changes maintain full backward compatibility while improving performance for data-intensive cryptocurrency exchange operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.bitteam import bitteam

--- Unit Tests ---

@pytest.fixture
def parser():
return bitteam()

--- 1. Basic Test Cases ---

def test_parse_trade_fetch_trades_basic(parser):
# Basic fetchTrades response
trade = {
"trade_id": 34970337,
"price": 37769.994793,
"base_volume": 0.00119062,
"quote_volume": 44.96971120044166,
"timestamp": 1700827234000,
"type": "buy",
"pair": "BTC_USDT"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 62.7μs -> 56.4μs (11.1% faster)

def test_parse_trade_fetch_my_trades_basic_maker_sell(parser):
# Basic fetchMyTrades response, maker, sell
trade = {
"id": 34875793,
"tradeId": "4368010",
"makerOrderId": 106742914,
"takerOrderId": 106745926,
"pairId": 2,
"quantity": "0.0027193",
"price": "1993.674994",
"isBuyerMaker": True,
"baseDecimals": 18,
"quoteDecimals": 6,
"side": "sell",
"timestamp": 1700602983,
"rewarded": True,
"makerUserId": 21639,
"takerUserId": 15912,
"baseCurrencyId": 2,
"quoteCurrencyId": 3,
"feeMaker": {
"amount": "0.00000543",
"symbol": "eth",
"userId": 21639,
"decimals": 18,
"symbolId": 2
},
"pair": "ETH_USDT",
"isCurrentSide": "maker"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 78.6μs -> 74.0μs (6.20% faster)

def test_parse_trade_fetch_my_trades_basic_taker_buy(parser):
# Basic fetchMyTrades response, taker, buy
trade = {
"id": 34875794,
"tradeId": "4368011",
"makerOrderId": 106742915,
"takerOrderId": 106745927,
"pairId": 2,
"quantity": "0.0020000",
"price": "2000.000000",
"isBuyerMaker": False,
"baseDecimals": 18,
"quoteDecimals": 6,
"side": "buy",
"timestamp": 1700603000,
"rewarded": False,
"makerUserId": 21639,
"takerUserId": 15912,
"baseCurrencyId": 2,
"quoteCurrencyId": 3,
"feeTaker": {
"amount": "0.5",
"symbol": "usdt",
"userId": 15912,
"decimals": 6,
"symbolId": 3
},
"pair": "ETH_USDT",
"isCurrentSide": "taker"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 77.1μs -> 69.4μs (11.1% faster)

def test_parse_trade_with_missing_fields(parser):
# Trade with missing optional fields
trade = {
"trade_id": 123,
"price": 100,
"base_volume": 1,
"timestamp": 1600000000000,
"type": "buy",
# no quote_volume, no pair
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 63.5μs -> 59.1μs (7.41% faster)

--- 2. Edge Test Cases ---

def test_parse_trade_side_flipping(parser):
# Maker, side=buy should flip to sell
trade = {
"id": 1,
"quantity": "1",
"price": "100",
"side": "buy",
"timestamp": 1000,
"pair": "BTC_USDT",
"isCurrentSide": "maker",
"makerOrderId": 42,
"feeMaker": {"amount": "0.1", "symbol": "btc"}
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 72.8μs -> 67.6μs (7.66% faster)

def test_parse_trade_side_no_flip_for_taker(parser):
# Taker, side=buy should remain buy
trade = {
"id": 2,
"quantity": "2",
"price": "200",
"side": "buy",
"timestamp": 2000,
"pair": "BTC_USDT",
"isCurrentSide": "taker",
"takerOrderId": 43,
"feeTaker": {"amount": "0.2", "symbol": "usdt"}
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 72.9μs -> 68.0μs (7.12% faster)

def test_parse_trade_handles_none_fee_fields(parser):
# Fee info missing entirely
trade = {
"id": 3,
"quantity": "3",
"price": "300",
"side": "sell",
"timestamp": 3000,
"pair": "BTC_USDT",
"isCurrentSide": "maker",
"makerOrderId": 44
# feeMaker missing
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 67.6μs -> 63.2μs (6.97% faster)

def test_parse_trade_handles_fee_symbol_mapping(parser):
# Fee symbol with mapping (e.g., XBT -> BTC)
trade = {
"id": 4,
"quantity": "1",
"price": "50000",
"side": "sell",
"timestamp": 4000,
"pair": "XBT_USDT",
"isCurrentSide": "maker",
"makerOrderId": 45,
"feeMaker": {"amount": "0.01", "symbol": "XBT"}
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 73.6μs -> 67.2μs (9.60% faster)

def test_parse_trade_handles_zero_and_negative_amounts(parser):
# Zero and negative amounts
trade = {
"id": 6,
"quantity": "0",
"price": "100",
"side": "sell",
"timestamp": 6000,
"pair": "BTC_USDT"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 63.3μs -> 60.3μs (5.03% faster)

trade['quantity'] = "-1"
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 31.8μs -> 31.1μs (2.27% faster)

def test_parse_trade_handles_missing_side(parser):
# No side/type field
trade = {
"id": 7,
"quantity": "1",
"price": "100",
"timestamp": 7000,
"pair": "BTC_USDT"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 62.9μs -> 58.3μs (7.97% faster)

def test_parse_trade_handles_missing_id(parser):
# No id/trade_id
trade = {
"quantity": "1",
"price": "100",
"timestamp": 8000,
"pair": "BTC_USDT"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 61.0μs -> 59.2μs (3.09% faster)

def test_parse_trade_handles_fee_cost_string(parser):
# Fee cost as string, should be parsed to float
trade = {
"id": 8,
"quantity": "1",
"price": "100",
"side": "buy",
"timestamp": 9000,
"pair": "BTC_USDT",
"isCurrentSide": "taker",
"takerOrderId": 46,
"feeTaker": {"amount": "0.123456", "symbol": "usdt"}
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 78.3μs -> 72.1μs (8.58% faster)

def test_parse_trade_handles_fee_cost_zero(parser):
# Fee cost is zero string
trade = {
"id": 9,
"quantity": "1",
"price": "100",
"side": "buy",
"timestamp": 10000,
"pair": "BTC_USDT",
"isCurrentSide": "taker",
"takerOrderId": 47,
"feeTaker": {"amount": "0", "symbol": "usdt"}
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 74.6μs -> 69.0μs (8.23% faster)

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

def test_parse_trade_large_batch(parser):
# Parse a large batch of trades (performance and correctness)
trades = []
for i in range(500): # 500 trades, each unique
trades.append({
"trade_id": i,
"price": str(100 + i),
"base_volume": str(0.01 * i),
"quote_volume": str((100 + i) * 0.01 * i),
"timestamp": 1700000000000 + i * 1000,
"type": "sell" if i % 2 == 0 else "buy",
"pair": "BTC_USDT"
})
results = [parser.parse_trade(trade) for trade in trades]

def test_parse_trade_large_batch_with_mixed_fields(parser):
# Batch with some missing fields and some with fees
trades = []
for i in range(200):
t = {
"trade_id": i,
"price": str(10 + i),
"base_volume": str(i),
"timestamp": 1600000000000 + i * 100,
"type": "buy",
"pair": "BTC_USDT"
}
if i % 10 == 0:
t["quote_volume"] = str((10 + i) * i)
if i % 15 == 0:
t["isCurrentSide"] = "taker"
t["takerOrderId"] = i + 1000
t["feeTaker"] = {"amount": str(i * 0.01), "symbol": "usdt"}
trades.append(t)
results = [parser.parse_trade(trade) for trade in trades]
# Check that fee is correct for 0, 15, 30, ...
for idx in range(0, 200, 15):
pass
# Check that missing quote_volume yields None
for idx in range(1, 10):
pass

def test_parse_trade_performance(parser):
# Simulate a large number of trades to check for performance bottlenecks
import time
trades = [{
"trade_id": i,
"price": "1.23",
"base_volume": "0.456",
"quote_volume": "0.56088",
"timestamp": 1700000000000 + i,
"type": "buy",
"pair": "BTC_USDT"
} for i in range(1000)]
start = time.time()
results = [parser.parse_trade(trade) for trade in trades]
elapsed = time.time() - start

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.bitteam import bitteam

========== UNIT TESTS ==========

@pytest.fixture
def parser():
return bitteam()

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

def test_basic_fetch_trades_buy(parser):
# Test a typical fetchTrades response (buy)
trade = {
"trade_id": 34970337,
"price": 37769.994793,
"base_volume": 0.00119062,
"quote_volume": 44.96971120044166,
"timestamp": 1700827234000,
"type": "buy",
"pair": "btc_usdt"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 61.6μs -> 57.1μs (7.79% faster)

def test_basic_fetch_trades_sell(parser):
# Test a typical fetchTrades response (sell)
trade = {
"trade_id": 34970338,
"price": 2000,
"base_volume": 0.5,
"quote_volume": 1000,
"timestamp": 1700828000000,
"type": "sell",
"pair": "eth_usdt"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 56.1μs -> 52.6μs (6.61% faster)

def test_basic_fetch_my_trades_maker_sell(parser):
# Test a typical fetchMyTrades response for a maker sell
trade = {
"id": 34875793,
"tradeId": "4368010",
"makerOrderId": 106742914,
"takerOrderId": 106745926,
"pairId": 2,
"quantity": "0.0027193",
"price": "1993.674994",
"isBuyerMaker": True,
"baseDecimals": 18,
"quoteDecimals": 6,
"side": "sell",
"timestamp": 1700602983,
"rewarded": True,
"makerUserId": 21639,
"takerUserId": 15912,
"baseCurrencyId": 2,
"quoteCurrencyId": 3,
"feeMaker": {
"amount": "0.00000543",
"symbol": "eth",
"userId": 21639,
"decimals": 18,
"symbolId": 2
},
"feeTaker": {
"amount": "0",
"symbol": "usdt",
"userId": 15912,
"decimals": 6,
"symbolId": 3,
"discountAmount": "0",
"discountSymbol": "btt",
"discountDecimals": 18,
"discountSymbolId": 5
},
"pair": "eth_usdt",
"createdAt": "2023-11-21T21:43:02.758Z",
"updatedAt": "2023-11-21T21:45:00.147Z",
"isCurrentSide": "maker"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 77.9μs -> 72.7μs (7.15% faster)

def test_basic_fetch_my_trades_taker_buy(parser):
# Test a typical fetchMyTrades response for a taker buy
trade = {
"id": 34875794,
"tradeId": "4368011",
"makerOrderId": 106742915,
"takerOrderId": 106745927,
"pairId": 2,
"quantity": "1.5",
"price": "100",
"side": "buy",
"timestamp": 1700604000,
"feeMaker": {
"amount": "0.01",
"symbol": "eth"
},
"feeTaker": {
"amount": "0.02",
"symbol": "usdt"
},
"pair": "eth_usdt",
"isCurrentSide": "taker"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 75.6μs -> 70.4μs (7.42% faster)

def test_basic_missing_pair(parser):
# Test missing 'pair' field
trade = {
"id": 124,
"price": "1",
"quantity": "2",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 64.7μs -> 60.3μs (7.31% faster)

def test_basic_missing_side_and_type(parser):
# Test missing 'side' and 'type'
trade = {
"id": 125,
"price": "1",
"quantity": "2",
"pair": "btc_usdt",
"timestamp": 1700000000000
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 62.1μs -> 57.9μs (7.27% faster)

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

def test_edge_timestamp_as_string(parser):
# Timestamp as string, should still work
trade = {
"trade_id": 1,
"price": "100",
"base_volume": "1",
"quote_volume": "100",
"timestamp": "1700827234000",
"type": "buy",
"pair": "btc_usdt"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 54.6μs -> 49.4μs (10.5% faster)

def test_edge_timestamp_as_int_and_isCurrentSide(parser):
# Timestamp as int, with isCurrentSide, should be multiplied by 1000
trade = {
"id": 2,
"price": "10",
"quantity": "2",
"pair": "btc_usdt",
"timestamp": 1700000,
"side": "buy",
"isCurrentSide": "taker"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 69.0μs -> 65.0μs (6.19% faster)

def test_edge_missing_amount_and_price(parser):
# Missing amount and price, should be None
trade = {
"id": 7,
"pair": "btc_usdt",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 56.6μs -> 51.6μs (9.62% faster)

def test_edge_cost_calculation(parser):
# If cost is present, it should be parsed as float
trade = {
"id": 8,
"price": "2",
"quantity": "3",
"cost": "6",
"pair": "btc_usdt",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 60.7μs -> 57.8μs (5.17% faster)

def test_edge_pair_with_no_delimiter(parser):
# Pair with no delimiter should just be uppercased
trade = {
"id": 11,
"price": "1",
"quantity": "1",
"pair": "btcusdt",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 64.5μs -> 60.9μs (5.86% faster)

def test_edge_nonstandard_pair_delimiter(parser):
# Pair with a different delimiter should handle gracefully
trade = {
"id": 12,
"price": "1",
"quantity": "1",
"pair": "btc-usdt",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 61.9μs -> 56.7μs (9.22% faster)

def test_edge_large_numbers(parser):
# Very large numbers for price, quantity
trade = {
"id": 13,
"price": "123456789012345.6789",
"quantity": "98765432109876.54321",
"pair": "btc_usdt",
"timestamp": 1700000000000,
"side": "buy"
}
codeflash_output = parser.parse_trade(trade); result = codeflash_output # 65.8μs -> 62.1μs (5.99% faster)

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

def test_large_scale_many_trades(parser):
# Test parsing a large batch of trades (performance and correctness)
trades = []
for i in range(1000):
trades.append({
"trade_id": i,
"price": str(100 + i),
"base_volume": str(1 + i % 10),
"quote_volume": str((100 + i) * (1 + i % 10)),
"timestamp": 1700000000000 + i * 1000,
"type": "buy" if i % 2 == 0 else "sell",
"pair": "btc_usdt"
})
results = [parser.parse_trade(t) for t in trades]
# Check a few random entries for correctness
for idx in [0, 10, 500, 999]:
t = trades[idx]
r = results[idx]

def test_large_scale_varied_pairs(parser):
# Test parsing many trades with varied pairs and sides
pairs = ['btc_usdt', 'eth_usdt', 'xrp_btc', 'ltc_eth']
types = ['buy', 'sell']
trades = []
for i in range(500):
pair = pairs[i % len(pairs)]
ttype = types[i % 2]
trades.append({
"trade_id": i,
"price": str(1 + i),
"base_volume": str(0.1 * (i % 10)),
"quote_volume": str((1 + i) * 0.1 * (i % 10)),
"timestamp": 1700000000000 + i * 100,
"type": ttype,
"pair": pair
})
results = [parser.parse_trade(t) for t in trades]
for idx in [0, 123, 250, 499]:
t = trades[idx]
r = results[idx]
base, quote = t['pair'].split('_')

def test_large_scale_missing_fields(parser):
# Test that missing fields in large scale don't raise exceptions
trades = [{"id": i} for i in range(200)]
results = [parser.parse_trade(t) for t in trades]
for r in results:
pass

def test_large_scale_fee_fields(parser):
# Test that fee fields are parsed correctly in large scale
trades = []
for i in range(100):
trades.append({
"id": i,
"price": "10",
"quantity": "5",
"pair": "btc_usdt",
"timestamp": 1700000000000 + i,
"side": "buy",
"isCurrentSide": "maker" if i % 2 == 0 else "taker",
"feeMaker": {
"amount": str(i * 0.01),
"symbol": "btc"
},
"feeTaker": {
"amount": str(i * 0.02),
"symbol": "usdt"
}
})
results = [parser.parse_trade(t) for t in trades]
for i, r in enumerate(results):
if i % 2 == 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-bitteam.parse_trade-mhuy26tk and push.