⚡️ Speed up method coinspot.parse_balance by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for coinspot.parse_balance in python/ccxt/coinspot.py

⏱️ Runtime : 18.7 milliseconds → 17.2 milliseconds (best of 40 runs)

📝 Explanation and details

The optimized code achieves an 8% speedup through several targeted micro-optimizations that reduce function call overhead and eliminate repeated lookups in performance-critical methods:

Key Optimizations Applied:

1. safe_string method caching: The original version calls Exchange.key_exists as a method lookup on every invocation. The optimized version caches this reference in a local variable (key_exists = Exchange.key_exists), reducing attribute lookup overhead by ~40% per call based on the profiler data.

2. safe_value_2 inlining: Instead of delegating through Exchange.safe_either(), the logic is inlined directly. This eliminates one level of function call indirection, reducing per-hit time from 3155ns to 2833ns (~10% improvement).

3. safe_balance loop optimizations:

   • Caches frequently-used method references (parse_number, safe_string, etc.) outside the hot loop
   • Uses direct iteration for code in codes: instead of for i in range(len(codes)) with indexing
   • Eliminates repeated balance[code] lookups by storing in local variable entry
   • Replaces expensive list operations for debt balance tracking

4. parse_balance method reference caching: Pre-fetches method references (safe_value_2, safe_currency_code, etc.) outside loops, avoiding repeated attribute lookups during iteration over currency data.

Why These Optimizations Work:

Python's attribute lookup mechanism (self.method_name) involves dictionary traversal through the method resolution order. By caching these lookups in local variables, we convert expensive attribute access into fast local variable access. In tight loops processing hundreds or thousands of currencies, this compounds significantly.

Test Case Performance:

• Small datasets (1-10 currencies): 5-11% improvement
• Large datasets (500-1000 currencies): 8-12% improvement, showing the optimizations scale well with data size
• The improvements are consistent across different input formats (dict vs list structures), indicating the optimizations target fundamental bottlenecks rather than specific edge cases

These optimizations are particularly valuable for financial applications processing large numbers of currency balances, where parse_balance is likely called frequently during portfolio updates or market data processing.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from ccxt.coinspot import coinspot

--- Unit Tests ---

@pytest.fixture
def cs():
return coinspot()

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

def test_single_currency_balance(cs):
# Basic: Single currency, balance as float
response = {'balance': {'BTC': 1.23}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 22.5μs -> 20.8μs (8.14% faster)

def test_multiple_currencies_balance(cs):
# Basic: Multiple currencies, balance as int/float
response = {'balance': {'BTC': 2, 'ETH': 3.5}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 30.4μs -> 27.3μs (11.4% faster)

def test_balance_key_variants(cs):
# Basic: Accepts 'balances' key
response = {'balances': {'BTC': 5, 'ETH': 10}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 29.2μs -> 27.1μs (7.95% faster)

def test_balance_as_string(cs):
# Basic: Balance values as strings
response = {'balance': {'BTC': '7.77', 'ETH': '0.01'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 27.9μs -> 25.8μs (8.10% faster)

def test_info_field_preserved(cs):
# Basic: 'info' field is preserved
response = {'balance': {'BTC': 1}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 21.4μs -> 19.6μs (8.99% faster)

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

def test_empty_balance_dict(cs):
# Edge: Empty balance dict
response = {'balance': {}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 7.03μs -> 6.76μs (4.09% faster)

def test_null_balance(cs):
# Edge: Null balance value
response = {'balance': {'BTC': None}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 20.3μs -> 19.2μs (5.57% faster)

def test_unusual_currency_code(cs):
# Edge: Unusual currency code (lowercase, mapped)
response = {'balance': {'xbt': 1.5}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 23.4μs -> 21.4μs (9.76% faster)

def test_balance_list_format(cs):
# Edge: List of dicts format (rare but supported)
response = {
'balance': [
{'BTC': {'balance': 10}},
{'ETH': {'balance': '15.5'}}
]
}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 28.9μs -> 25.9μs (11.5% faster)

def test_balance_with_free_and_used(cs):
# Edge: If free and used are present, total is calculated
response = {'balance': {'BTC': {'free': '5', 'used': '3'}}}
# parse_balance expects just a number, so simulate the inner logic
# We'll test safe_balance directly for this edge
balance = {
'BTC': {'free': '5', 'used': '3'},
'info': {},
}
result = cs.safe_balance(balance)

def test_balance_with_total_and_used(cs):
# Edge: If total and used are present, free is calculated
balance = {
'BTC': {'total': '10', 'used': '4'},
'info': {},
}
result = cs.safe_balance(balance)

def test_balance_with_total_and_free(cs):
# Edge: If total and free are present, used is calculated
balance = {
'BTC': {'total': '20', 'free': '7'},
'info': {},
}
result = cs.safe_balance(balance)

def test_balance_with_zero(cs):
# Edge: Zero balances
response = {'balance': {'BTC': 0, 'ETH': '0.0'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 28.3μs -> 26.6μs (6.47% faster)

def test_balance_with_negative(cs):
# Edge: Negative balances (debt/overdrawn)
response = {'balance': {'BTC': -5, 'ETH': '-2.5'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 28.3μs -> 26.0μs (8.73% faster)

def test_balance_with_non_numeric(cs):
# Edge: Non-numeric balance value
response = {'balance': {'BTC': 'not_a_number'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 22.9μs -> 20.9μs (9.65% faster)

def test_balance_with_extra_fields(cs):
# Edge: Balance dict with extra fields
response = {'balance': {'BTC': 1, 'ETH': 2}, 'timestamp': 1234567890, 'foo': 'bar'}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 27.9μs -> 25.9μs (7.94% faster)

def test_balance_with_mapped_currency(cs):
# Edge: Currency code that should be mapped via commonCurrencies
response = {'balance': {'BCHSV': 42}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 21.4μs -> 19.4μs (10.3% faster)

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

def test_large_number_of_currencies(cs):
# Large scale: 1000 currencies
currencies = {f'C{i}': i for i in range(1000)}
response = {'balance': currencies}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 4.24ms -> 3.92ms (8.18% faster)
for i in range(1000):
code = f'C{i}'

def test_large_balance_list(cs):
# Large scale: List of 500 currency dicts
balances = [{f'C{i}': {'balance': i}} for i in range(500)]
response = {'balance': balances}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 2.25ms -> 2.00ms (12.7% faster)
for i in range(500):
code = f'C{i}'

def test_large_balances_with_free_and_used(cs):
# Large scale: 100 currencies with free and used fields
balance = {f'C{i}': {'free': str(i), 'used': str(i)} for i in range(100)}
balance['info'] = {}
result = cs.safe_balance(balance)
for i in range(100):
code = f'C{i}'

def test_large_balances_with_total_and_used(cs):
# Large scale: 100 currencies with total and used fields
balance = {f'C{i}': {'total': str(i * 2), 'used': str(i)} for i in range(100)}
balance['info'] = {}
result = cs.safe_balance(balance)
for i in range(100):
code = f'C{i}'

def test_large_balances_with_total_and_free(cs):
# Large scale: 100 currencies with total and free fields
balance = {f'C{i}': {'total': str(i * 2), 'free': str(i)} for i in range(100)}
balance['info'] = {}
result = cs.safe_balance(balance)
for i in range(100):
code = f'C{i}'

------------------ DETERMINISM TEST CASES ------------------

def test_deterministic_output(cs):
# Determinism: Same input always yields same output
response = {'balance': {'BTC': 1.23, 'ETH': '2.34'}}
codeflash_output = cs.parse_balance(response); result1 = codeflash_output # 29.1μs -> 28.3μs (2.70% faster)
codeflash_output = cs.parse_balance(response); result2 = codeflash_output # 14.8μs -> 13.3μs (11.3% faster)

------------------ INVALID INPUT TEST CASES ------------------

def test_balance_key_is_empty_list(cs):
# Edge: 'balance' is an empty list
response = {'balance': []}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 7.10μs -> 6.93μs (2.54% faster)

def test_balance_with_mixed_types(cs):
# Edge: Mixed types in balance values
response = {'balance': {'BTC': 1, 'ETH': '2.0', 'LTC': None, 'DOGE': 'not_a_number'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 40.4μs -> 37.8μs (6.91% faster)

def test_balance_with_currency_id_none(cs):
# Edge: Currency ID is None
response = {'balance': {None: 5}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 19.8μs -> 18.9μs (4.98% faster)

def test_balance_with_currency_id_empty_string(cs):
# Edge: Currency ID is empty string
response = {'balance': {'': 10}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 21.8μs -> 19.8μs (10.3% faster)

def test_balance_with_currency_id_special_chars(cs):
# Edge: Currency ID is special characters
response = {'balance': {'$BTC!': 99}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 21.4μs -> 19.5μs (9.89% 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.coinspot import coinspot

Unit tests for coinspot.parse_balance

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

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

def test_single_currency_balance(cs):
# Test with one currency, normal input
response = {'balance': {'BTC': 1.2345}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 22.9μs -> 21.9μs (4.22% faster)

def test_multiple_currencies_balance(cs):
# Test with several currencies
response = {'balance': {'BTC': 1.0, 'ETH': 2.5, 'DOGE': 1000}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 36.1μs -> 33.1μs (9.15% faster)

def test_balance_key_vs_balances_key(cs):
# Test with 'balances' instead of 'balance'
response = {'balances': {'BTC': 42.0, 'ETH': 0.001}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 31.6μs -> 28.6μs (10.5% faster)

def test_string_balance_values(cs):
# Test with string values for balances
response = {'balance': {'BTC': '1.5', 'ETH': '0.25'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 28.1μs -> 25.8μs (9.04% faster)

def test_list_balances_format(cs):
# Test with Coinspot's list-of-dicts format
response = {'balance': [
{'BTC': {'balance': 0.5}},
{'ETH': {'balance': 1.5}},
]}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 32.3μs -> 29.3μs (10.1% faster)

def test_currency_code_mapping(cs):
# Test Coinspot's currency code mapping
response = {'balance': {'XBT': 2.0, 'BCHSV': 3.0}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 28.8μs -> 27.8μs (3.36% faster)

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

def test_empty_balance_dict(cs):
# Test with empty balance dict
response = {'balance': {}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 7.22μs -> 6.61μs (9.29% faster)

def test_none_balance_value(cs):
# Test with None as balance value
response = {'balance': {'BTC': None}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 20.4μs -> 19.1μs (7.07% faster)

def test_zero_balance(cs):
# Test with zero balance
response = {'balance': {'BTC': 0}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 20.5μs -> 19.7μs (4.17% faster)

def test_negative_balance(cs):
# Test with negative balance
response = {'balance': {'BTC': -1.5}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 23.1μs -> 22.4μs (3.44% faster)

def test_unusual_currency_code(cs):
# Test with lower-case, mixed-case, and unknown code
response = {'balance': {'xbt': 1.1, 'bchsv': 2.2, 'foo': 3.3}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 35.8μs -> 32.2μs (11.2% faster)

def test_list_balances_multiple_currencies(cs):
# Test list-of-dicts format with multiple currencies per dict
response = {'balance': [
{'BTC': {'balance': 0.5}, 'ETH': {'balance': 0.1}},
{'DOGE': {'balance': 100}},
]}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 36.8μs -> 34.5μs (6.57% faster)

def test_balance_with_extra_keys(cs):
# Test with extra keys in the response
response = {'balance': {'BTC': 1.0, 'ETH': 2.0}, 'timestamp': 1234567890, 'foo': 'bar'}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 29.2μs -> 27.4μs (6.47% faster)

def test_balance_with_non_numeric(cs):
# Test with non-numeric balance value
response = {'balance': {'BTC': 'not_a_number'}}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 22.5μs -> 20.4μs (10.1% faster)

def test_balance_with_null_entry(cs):
# Test with null currency entry in list
response = {'balance': [
{'BTC': {'balance': None}},
{'ETH': {'balance': 2.0}},
]}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 29.0μs -> 26.8μs (8.15% faster)

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

def test_large_number_of_currencies(cs):
# Test with 1000 currencies
currencies = {f'C{i}': float(i) for i in range(1000)}
response = {'balance': currencies}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 4.33ms -> 3.99ms (8.58% faster)
for i in range(1000):
code = f'C{i}'.upper()

def test_large_list_balances(cs):
# Test with list-of-dicts, each with 10 currencies, 100 dicts total
balances_list = []
for i in range(100):
balances_list.append({f'C{i10+j}': {'balance': float(i10+j)} for j in range(10)})
response = {'balance': balances_list}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 4.41ms -> 4.06ms (8.41% faster)
for i in range(1000):
code = f'C{i}'.upper()

def test_large_balances_with_string_values(cs):
# Test with 500 currencies, all string values
currencies = {f'C{i}': str(i * 0.01) for i in range(500)}
response = {'balance': currencies}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 2.12ms -> 1.95ms (8.60% faster)
for i in range(500):
code = f'C{i}'.upper()

def test_large_balances_with_mixed_types(cs):
# Test with 100 currencies, alternating float/int/string/None
currencies = {}
for i in range(100):
if i % 4 == 0:
val = float(i)
elif i % 4 == 1:
val = i
elif i % 4 == 2:
val = str(i)
else:
val = None
currencies[f'C{i}'] = val
response = {'balance': currencies}
codeflash_output = cs.parse_balance(response); result = codeflash_output # 448μs -> 409μs (9.61% faster)
for i in range(100):
code = f'C{i}'.upper()
if i % 4 == 3:
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-coinspot.parse_balance-mhw208rm and push.