⚡️ Speed up method digifinex.parse_trading_fee by 24%

[codeflash-ai]

📄 24% (0.24x) speedup for digifinex.parse_trading_fee in python/ccxt/digifinex.py

⏱️ Runtime : 4.00 milliseconds → 3.24 milliseconds (best of 37 runs)

📝 Explanation and details

The optimization achieves a 23% speedup by eliminating redundant method calls and leveraging Python's optimized dictionary operations in two critical utility methods:

Key Optimizations:

1. safe_string() fast-path: Instead of always calling Exchange.key_exists() (which involves try/catch overhead), the optimized version uses dict.get() directly for dictionary inputs - the most common case. This eliminates the expensive exception handling path for normal dictionary lookups while preserving correctness for edge cases via fallback.

2. safe_number() call inlining: Rather than calling safe_string() and then parse_number(), the optimized version inlines the dictionary lookup logic directly. This eliminates one method call per invocation - significant given this method is called 2,072 times in the profile.

Why It's Faster:

• Dictionary access optimization: dict.get(key, None) is much faster than try/catch dictionary access in key_exists()
• Reduced call stack depth: Inlining eliminates method call overhead, especially impactful for high-frequency utility functions
• Branch prediction friendly: The isinstance(obj, dict) check is highly predictable since most inputs are dictionaries

Test Results Show Consistent Gains:

• Basic cases: 4-9% faster due to optimized dictionary access
• Edge cases (missing fields, empty dicts): 10-21% faster as the fast-path logic handles None/empty values more efficiently
• Large scale tests: Up to 37% faster, demonstrating the cumulative effect of eliminating thousands of redundant method calls

The optimizations are particularly effective because safe_string() and safe_number() are fundamental utility methods called extensively throughout the CCXT library's data parsing operations, making even small per-call improvements compound significantly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.digifinex import digifinex

unit tests

@pytest.fixture
def exchange():
return digifinex()

-------------------------------

1. Basic Test Cases

-------------------------------

def test_basic_standard_fee(exchange):
# Standard input, all fields present as strings
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.8μs -> 11.1μs (5.78% faster)

def test_basic_fee_with_market(exchange):
# Market argument passed, overrides symbol logic
fee = {
"instrument_id": "ETHUSDT",
"taker_fee_rate": "0.002",
"maker_fee_rate": "0.001"
}
market = {'symbol': 'ETH/USDT'}
codeflash_output = exchange.parse_trading_fee(fee, market); result = codeflash_output # 11.5μs -> 10.5μs (9.95% faster)

def test_basic_fee_with_numeric_rates(exchange):
# Fee rates given as numeric types
fee = {
"instrument_id": "LTCUSDTPERP",
"taker_fee_rate": 0.0007,
"maker_fee_rate": 0.0004
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 14.0μs -> 13.4μs (4.68% faster)

def test_basic_fee_with_extra_fields(exchange):
# Fee dict contains extra irrelevant fields
fee = {
"instrument_id": "BNBUSDT",
"taker_fee_rate": "0.0012",
"maker_fee_rate": "0.0008",
"extra_field": "irrelevant"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.7μs -> 11.0μs (6.74% faster)

-------------------------------

2. Edge Test Cases

-------------------------------

def test_edge_missing_instrument_id(exchange):
# instrument_id missing
fee = {
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.8μs -> 10.4μs (13.1% faster)

def test_edge_missing_fee_rates(exchange):
# maker_fee_rate and taker_fee_rate missing
fee = {
"instrument_id": "BTCUSDTPERP"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.2μs -> 9.84μs (14.0% faster)

def test_edge_fee_rates_are_none(exchange):
# Fee rates explicitly None
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": None,
"maker_fee_rate": None
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.7μs -> 9.70μs (10.4% faster)

def test_edge_fee_rates_are_empty_strings(exchange):
# Fee rates are empty strings
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "",
"maker_fee_rate": ""
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.5μs -> 9.77μs (7.41% faster)

def test_edge_fee_rates_are_invalid_strings(exchange):
# Fee rates are non-numeric strings
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "abc",
"maker_fee_rate": "xyz"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 13.6μs -> 13.0μs (4.64% faster)

def test_edge_market_id_is_empty_string(exchange):
# instrument_id is empty string
fee = {
"instrument_id": "",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.0μs -> 10.2μs (8.33% faster)

def test_edge_market_id_is_none(exchange):
# instrument_id is None
fee = {
"instrument_id": None,
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.2μs -> 10.2μs (10.4% faster)

def test_edge_fee_is_empty_dict(exchange):
# Fee dict is empty
fee = {}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.9μs -> 8.98μs (21.6% faster)

def test_edge_market_is_none(exchange):
# Market argument is None, should not break
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee, None); result = codeflash_output # 11.7μs -> 11.0μs (6.31% faster)

def test_edge_fee_rates_are_large_numbers(exchange):
# Fee rates are very large numbers
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "1000000",
"maker_fee_rate": "999999"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 12.4μs -> 11.3μs (9.34% faster)

def test_edge_fee_rates_are_negative(exchange):
# Fee rates are negative
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "-0.0005",
"maker_fee_rate": "-0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.7μs -> 11.2μs (3.73% faster)

def test_edge_fee_rates_are_zero(exchange):
# Fee rates are zero
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0",
"maker_fee_rate": "0"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.7μs -> 11.0μs (6.76% faster)

-------------------------------

3. Large Scale Test Cases

-------------------------------

def test_large_scale_many_fees(exchange):
# Test with a large list of fee dicts
n = 500
fees = [
{
"instrument_id": f"SYM{i}",
"taker_fee_rate": str(0.001 + i * 0.00001),
"maker_fee_rate": str(0.0005 + i * 0.00001)
}
for i in range(n)
]
results = [exchange.parse_trading_fee(fee) for fee in fees]
for i, result in enumerate(results):
pass

def test_large_scale_all_missing_fields(exchange):
# Test with many fee dicts missing all fields
n = 300
fees = [{} for _ in range(n)]
results = [exchange.parse_trading_fee(fee) for fee in fees]
for result in results:
pass

def test_large_scale_mixed_valid_and_invalid(exchange):
# Mix of valid and invalid fee dicts
n = 100
fees = []
for i in range(n):
if i % 2 == 0:
fees.append({
"instrument_id": f"SYM{i}",
"taker_fee_rate": str(0.001 + i * 0.00001),
"maker_fee_rate": str(0.0005 + i * 0.00001)
})
else:
fees.append({
"instrument_id": None,
"taker_fee_rate": "abc",
"maker_fee_rate": ""
})
results = [exchange.parse_trading_fee(fee) for fee in fees]
for i, result in enumerate(results):
if i % 2 == 0:
pass
else:
pass

def test_large_scale_with_market_argument(exchange):
# Test with a large list of fee dicts and market argument
n = 200
fees = [
{
"instrument_id": f"SYM{i}",
"taker_fee_rate": str(0.001 + i * 0.00001),
"maker_fee_rate": str(0.0005 + i * 0.00001)
}
for i in range(n)
]
markets = [{'symbol': f"MARKET{i}"} for i in range(n)]
results = [exchange.parse_trading_fee(fee, market) for fee, market in zip(fees, markets)]
for i, result in enumerate(results):
pass

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

--- Unit Tests ---

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

1. Basic Test Cases

def test_basic_valid_fee(exchange):
# Normal input, both rates as strings
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.9μs -> 11.0μs (8.10% faster)

def test_basic_fee_with_market_argument(exchange):
# Provide market argument, symbol should match market['symbol']
fee = {
"instrument_id": "ETHUSDT",
"taker_fee_rate": "0.001",
"maker_fee_rate": "0.0008"
}
market = {'symbol': 'ETHUSDT'}
codeflash_output = exchange.parse_trading_fee(fee, market); result = codeflash_output # 11.6μs -> 10.6μs (9.17% faster)

def test_basic_fee_with_numeric_rates(exchange):
# Rates as numbers instead of strings
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": 0.0004,
"maker_fee_rate": 0.0002
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 14.2μs -> 13.1μs (8.61% faster)

def test_basic_fee_with_extra_fields(exchange):
# Fee dict with extra irrelevant fields
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003",
"irrelevant": "foo",
"another": 123
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.7μs -> 10.9μs (7.38% faster)

2. Edge Test Cases

def test_missing_instrument_id(exchange):
# instrument_id missing, should set symbol to None
fee = {
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.8μs -> 10.5μs (12.6% faster)

def test_missing_maker_fee_rate(exchange):
# maker_fee_rate missing, should set maker to None
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.9μs -> 10.5μs (13.9% faster)

def test_missing_taker_fee_rate(exchange):
# taker_fee_rate missing, should set taker to None
fee = {
"instrument_id": "BTCUSDTPERP",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 12.0μs -> 10.6μs (13.8% faster)

def test_all_rates_missing(exchange):
# Both rates missing, should set both to None
fee = {
"instrument_id": "BTCUSDTPERP"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.5μs -> 9.65μs (19.0% faster)

def test_empty_dict(exchange):
# Empty dict, all fields should be None except info
fee = {}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.6μs -> 9.06μs (17.1% faster)

def test_rates_as_empty_strings(exchange):
# Fee rates are empty strings, should set to None
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "",
"maker_fee_rate": ""
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.7μs -> 9.62μs (11.2% faster)

def test_rates_as_none(exchange):
# Fee rates are None, should set to None
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": None,
"maker_fee_rate": None
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 10.8μs -> 9.65μs (12.2% faster)

def test_rates_as_invalid_strings(exchange):
# Fee rates are not parseable as numbers, should set to None
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "notanumber",
"maker_fee_rate": "NaN"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 13.4μs -> 12.5μs (6.79% faster)

def test_market_argument_overrides_symbol(exchange):
# Provide market argument with different symbol than instrument_id
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
market = {'symbol': 'OVERRIDE'}
codeflash_output = exchange.parse_trading_fee(fee, market); result = codeflash_output # 11.5μs -> 10.6μs (8.80% faster)

def test_market_argument_none(exchange):
# Provide market argument as None, should fallback to instrument_id
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee, None); result = codeflash_output # 11.7μs -> 10.8μs (8.33% faster)

def test_instrument_id_is_none(exchange):
# instrument_id is None, symbol should be None
fee = {
"instrument_id": None,
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.4μs -> 10.3μs (11.2% faster)

def test_instrument_id_is_empty_string(exchange):
# instrument_id is empty string, symbol should be None
fee = {
"instrument_id": "",
"taker_fee_rate": "0.0005",
"maker_fee_rate": "0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.3μs -> 10.3μs (9.97% faster)

def test_fee_rates_are_zero(exchange):
# Fee rates are zero
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "0",
"maker_fee_rate": "0"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.6μs -> 10.6μs (8.94% faster)

def test_fee_rates_are_negative(exchange):
# Fee rates are negative numbers
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "-0.0005",
"maker_fee_rate": "-0.0003"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.8μs -> 10.8μs (9.08% faster)

def test_fee_rates_are_large(exchange):
# Fee rates are large numbers
fee = {
"instrument_id": "BTCUSDTPERP",
"taker_fee_rate": "12345.6789",
"maker_fee_rate": "98765.4321"
}
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 11.8μs -> 10.8μs (8.38% faster)

3. Large Scale Test Cases

def test_large_scale_many_fees(exchange):
# Test with a list of many fee dicts
n = 500
fees = [
{
"instrument_id": f"SYMBOL{i}",
"taker_fee_rate": str(0.001 * i),
"maker_fee_rate": str(0.0005 * i)
}
for i in range(n)
]
for i, fee in enumerate(fees):
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 1.79ms -> 1.52ms (18.0% faster)

def test_large_scale_missing_fields(exchange):
# Test with many fee dicts, some missing fields
n = 300
fees = []
for i in range(n):
fee = {}
if i % 3 == 0:
fee["instrument_id"] = f"SYMBOL{i}"
if i % 5 == 0:
fee["maker_fee_rate"] = str(0.0001 * i)
if i % 7 == 0:
fee["taker_fee_rate"] = str(0.0002 * i)
fees.append(fee)
for i, fee in enumerate(fees):
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 1.09ms -> 823μs (31.9% faster)
expected_symbol = fee.get("instrument_id", None)
expected_maker = float(fee["maker_fee_rate"]) if "maker_fee_rate" in fee else None
expected_taker = float(fee["taker_fee_rate"]) if "taker_fee_rate" in fee else None

def test_large_scale_all_empty(exchange):
# Test with many empty dicts
n = 200
fees = [{} for _ in range(n)]
for fee in fees:
codeflash_output = exchange.parse_trading_fee(fee); result = codeflash_output # 716μs -> 523μs (36.9% faster)

def test_large_scale_performance(exchange):
# Test performance with 1000 fee dicts (not measuring time, just ensuring no crash)
n = 1000
fees = [
{
"instrument_id": f"SYMBOL{i}",
"taker_fee_rate": str(0.001 * i),
"maker_fee_rate": str(0.0005 * i)
}
for i in range(n)
]
results = [exchange.parse_trading_fee(fee) for fee in fees]
for i, result in enumerate(results):
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-digifinex.parse_trading_fee-mhu8iqyg and push.