⚡️ Speed up method bittrade.parse_balance by 30%

[codeflash-ai]

📄 30% (0.30x) speedup for bittrade.parse_balance in python/ccxt/bittrade.py

⏱️ Runtime : 18.5 milliseconds → 14.2 milliseconds (best of 81 runs)

📝 Explanation and details

The optimized code achieves a 30% speedup primarily through eliminating redundant dictionary lookups and reducing method call overhead in performance-critical paths.

Key Performance Optimizations:

1. safe_string and safe_value - Exception-based lookup (~42% faster)

   • Replaced double dictionary access (key_exists + dictionary[key]) with try-catch pattern
   • The original code called key_exists which performed multiple checks, then accessed dictionary[key] again
   • New approach uses direct dictionary access with exception handling, reducing from 2 lookups to 1

2. safe_balance - Method hoisting and loop optimization (~6% faster)

   • Hoisted frequently-used method references (self.omit, self.parse_number, Precise.string_add, etc.) outside the loop
   • Pre-allocated output dictionaries (balance_free, balance_used, balance_total) to avoid repeated key assignments
   • Replaced range-based iteration with direct iteration over codes, eliminating index operations
   • Cached parsed values to avoid redundant assignments

3. parse_balance - Method reference caching and streamlined logic (~4% faster)

   • Hoisted method references (safe_value, safe_string, safe_currency_code) to local variables at function start
   • Simplified account retrieval logic using result.get(code) instead of if code in result check
   • Used balance.get('type') to avoid potential KeyError exceptions

Why These Optimizations Work:

• Dictionary access patterns: The line profiler shows safe_string is called 19,941 times, making the double-lookup elimination highly impactful
• Method call overhead: Python method resolution is expensive in tight loops - caching references as local variables reduces this overhead significantly
• Memory allocation: Pre-allocating dictionaries and reusing parsed values reduces garbage collection pressure

Test Results Show Consistent Gains:

• Small datasets (single currencies): 15-22% faster
• Medium datasets (multiple currencies): 15-20% faster
• Large datasets (500+ currencies): 30-48% faster, indicating the optimizations scale well with input size

The optimizations are particularly effective for workloads processing large numbers of balance entries, which is common in cryptocurrency exchange integrations where this code would be frequently called during portfolio updates and trading operations.

✅ Correctness verification report:

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

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

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

def test_single_currency_trade_balance(parser):
    # Test a single currency with only 'trade' balance
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': '0.5'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 21.4μs -> 18.0μs (19.0% faster)

def test_single_currency_frozen_balance(parser):
    # Test a single currency with only 'frozen' balance
    response = {
        'data': {
            'list': [
                {'currency': 'ETH', 'type': 'frozen', 'balance': '1.2'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 21.3μs -> 17.7μs (20.0% faster)

def test_single_currency_trade_and_frozen(parser):
    # Test a single currency with both 'trade' and 'frozen' balances
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': '0.5'},
                {'currency': 'BTC', 'type': 'frozen', 'balance': '0.2'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 34.7μs -> 30.0μs (15.5% faster)

def test_multiple_currencies(parser):
    # Test multiple currencies with various combinations
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': '1.0'},
                {'currency': 'ETH', 'type': 'trade', 'balance': '2.0'},
                {'currency': 'ETH', 'type': 'frozen', 'balance': '0.5'},
                {'currency': 'USDT', 'type': 'frozen', 'balance': '10.0'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 47.3μs -> 39.2μs (20.4% faster)

def test_currency_code_mapping(parser):
    # Test mapping of currency codes (e.g., XBT -> BTC)
    response = {
        'data': {
            'list': [
                {'currency': 'XBT', 'type': 'trade', 'balance': '0.7'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 20.9μs -> 17.1μs (22.0% faster)

# ------------------ Edge Test Cases ------------------

def test_empty_list(parser):
    # Test response with empty list
    response = {'data': {'list': []}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 5.88μs -> 5.26μs (11.8% faster)


def test_missing_list_key(parser):
    # Test response with 'data' but missing 'list'
    response = {'data': {}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 6.42μs -> 6.21μs (3.46% faster)

def test_zero_balances(parser):
    # Test zero balances for both trade and frozen
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': '0'},
                {'currency': 'BTC', 'type': 'frozen', 'balance': '0'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 34.7μs -> 29.8μs (16.6% faster)

def test_negative_balances(parser):
    # Test negative balances (should be handled as floats)
    response = {
        'data': {
            'list': [
                {'currency': 'ETH', 'type': 'trade', 'balance': '-0.1'},
                {'currency': 'ETH', 'type': 'frozen', 'balance': '-0.2'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 35.2μs -> 31.1μs (13.3% faster)

def test_string_and_numeric_balance(parser):
    # Test balances given as numbers instead of strings
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': 1},
                {'currency': 'BTC', 'type': 'frozen', 'balance': 2.5}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 39.2μs -> 33.6μs (16.7% faster)

def test_duplicate_types(parser):
    # Test duplicate types for the same currency (should overwrite)
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': '1'},
                {'currency': 'BTC', 'type': 'trade', 'balance': '2'},  # Should overwrite previous
                {'currency': 'BTC', 'type': 'frozen', 'balance': '3'},
                {'currency': 'BTC', 'type': 'frozen', 'balance': '4'}  # Should overwrite previous
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 40.5μs -> 34.3μs (17.9% faster)

def test_unexpected_type_ignored(parser):
    # Test an unexpected type (should be ignored)
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'bonus', 'balance': '10'},
                {'currency': 'BTC', 'type': 'trade', 'balance': '1'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 25.7μs -> 21.2μs (21.1% faster)

def test_currency_case_insensitivity(parser):
    # Test that currency code is case-insensitive
    response = {
        'data': {
            'list': [
                {'currency': 'btc', 'type': 'trade', 'balance': '1'}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 20.5μs -> 17.7μs (15.8% faster)

def test_null_balance_field(parser):
    # Test a balance field that is None
    response = {
        'data': {
            'list': [
                {'currency': 'BTC', 'type': 'trade', 'balance': None}
            ]
        }
    }
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 19.6μs -> 16.4μs (19.8% faster)

# ------------------ Large Scale Test Cases ------------------

def test_large_number_of_currencies(parser):
    # Test with 500 currencies, each with trade and frozen balances
    n = 500
    balances = []
    for i in range(n):
        balances.append({'currency': f'C{i}', 'type': 'trade', 'balance': str(i)})
        balances.append({'currency': f'C{i}', 'type': 'frozen', 'balance': str(i+1)})
    response = {'data': {'list': balances}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 4.96ms -> 3.80ms (30.5% faster)
    for i in range(n):
        code = f'C{i}'.upper()

def test_large_single_currency_many_types(parser):
    # Test with a single currency but many balance types (only 'trade' and 'frozen' should be used)
    balances = []
    for i in range(100):
        balances.append({'currency': 'BTC', 'type': 'trade', 'balance': str(i)})
        balances.append({'currency': 'BTC', 'type': 'frozen', 'balance': str(i+1)})
        balances.append({'currency': 'BTC', 'type': 'bonus', 'balance': str(i+2)})  # Should be ignored
    response = {'data': {'list': balances}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 827μs -> 667μs (23.9% faster)

def test_performance_large_balances(parser):
    # Test performance with 999 currencies, only 'trade' type
    n = 999
    balances = [{'currency': f'C{i}', 'type': 'trade', 'balance': str(i)} for i in range(n)]
    response = {'data': {'list': balances}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 4.51ms -> 3.08ms (46.4% faster)
    for i in range(n):
        code = f'C{i}'.upper()

def test_large_balances_with_missing_fields(parser):
    # Test with some missing 'balance' fields in a large list
    n = 500
    balances = []
    for i in range(n):
        bal = str(i) if i % 2 == 0 else None
        balances.append({'currency': f'C{i}', 'type': 'trade', 'balance': bal})
    response = {'data': {'list': balances}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 2.25ms -> 1.53ms (47.6% faster)
    for i in range(n):
        code = f'C{i}'.upper()
        if i % 2 == 0:
            pass
        else:
            pass

def test_large_balances_with_varied_types(parser):
    # Test with many currencies, each with only one random type (trade or frozen)
    n = 500
    balances = []
    for i in range(n):
        t = 'trade' if i % 2 == 0 else 'frozen'
        balances.append({'currency': f'C{i}', 'type': t, 'balance': str(i)})
    response = {'data': {'list': balances}}
    codeflash_output = parser.parse_balance(response); result = codeflash_output # 2.29ms -> 1.54ms (48.4% faster)
    for i in range(n):
        code = f'C{i}'.upper()
        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.

import pytest
from ccxt.bittrade import bittrade

# --- function to test (minimal stub for test context) ---
# We'll define a minimal working version of bittrade.parse_balance and its dependencies
# based on the provided source code and CCXT conventions.

class Precise:
    @staticmethod
    def string_add(s1, s2):
        if s1 is None and s2 is None:
            return None
        if s1 is None:
            return s2
        if s2 is None:
            return s1
        return str(float(s1) + float(s2))

    @staticmethod
    def string_sub(s1, s2):
        if s1 is None or s2 is None:
            return None
        return str(float(s1) - float(s2))

class MockExchange:
    def __init__(self):
        # For currency code normalization
        self.currencies_by_id = {}
        self.commonCurrencies = {'XBT': 'BTC', 'BCC': 'BCH', 'BCHSV': 'BSV'}

    @staticmethod
    def key_exists(dictionary, key):
        if hasattr(dictionary, '__getitem__') and not isinstance(dictionary, str):
            if isinstance(dictionary, list) and type(key) is not int:
                return False
            try:
                value = dictionary[key]
                return value is not None and value != ''
            except LookupError:
                return False
        return False

    @staticmethod
    def safe_string(dictionary, key, default_value=None):
        return str(dictionary[key]) if MockExchange.key_exists(dictionary, key) else default_value

    @staticmethod
    def safe_value(dictionary, key, default_value=None):
        return dictionary[key] if MockExchange.key_exists(dictionary, key) else default_value

    def safe_currency(self, currencyId, currency=None):
        # Only normalization for test
        if currencyId is None and currency is not None:
            return currency
        code = currencyId
        if currencyId is not None:
            code = self.common_currency_code(currencyId.upper())
        return {'id': currencyId, 'code': code, 'precision': None}

    def common_currency_code(self, currencyId):
        return self.commonCurrencies.get(currencyId, currencyId)

    def safe_currency_code(self, currencyId, currency=None):
        currency = self.safe_currency(currencyId, currency)
        return currency['code']

    def account(self):
        return {'free': None, 'used': None, 'total': None}

    def parse_number(self, value, default=None):
        if value is None:
            return default
        try:
            return float(value)
        except Exception:
            return default

    @staticmethod
    def omit(d, *args):
        if isinstance(d, dict):
            result = d.copy()
            for arg in args:
                if type(arg) is list:
                    for key in arg:
                        if key in result:
                            del result[key]
                else:
                    if arg in result:
                        del result[arg]
            return result
        return d

    def safe_balance(self, balance):
        balances = self.omit(balance, ['info', 'timestamp', 'datetime', 'free', 'used', 'total'])
        codes = list(balances.keys())
        balance['free'] = {}
        balance['used'] = {}
        balance['total'] = {}
        debtBalance = {}
        for code in codes:
            total = self.safe_string(balance[code], 'total')
            free = self.safe_string(balance[code], 'free')
            used = self.safe_string(balance[code], 'used')
            debt = self.safe_string(balance[code], 'debt')
            if (total is None) and (free is not None) and (used is not None):
                total = Precise.string_add(free, used)
            if (free is None) and (total is not None) and (used is not None):
                free = Precise.string_sub(total, used)
            if (used is None) and (total is not None) and (free is not None):
                used = Precise.string_sub(total, free)
            balance[code]['free'] = self.parse_number(free)
            balance[code]['used'] = self.parse_number(used)
            balance[code]['total'] = self.parse_number(total)
            balance['free'][code] = balance[code]['free']
            balance['used'][code] = balance[code]['used']
            balance['total'][code] = balance[code]['total']
            if debt is not None:
                balance[code]['debt'] = self.parse_number(debt)
                debtBalance[code] = balance[code]['debt']
        if debtBalance:
            balance['debt'] = debtBalance
        return balance

    def parse_balance(self, response):
        balances = self.safe_value(response.get('data', {}), 'list', [])
        result = {'info': response}
        for balance in balances:
            currencyId = self.safe_string(balance, 'currency')
            code = self.safe_currency_code(currencyId)
            account = result.get(code, self.account())
            if balance['type'] == 'trade':
                account['free'] = self.safe_string(balance, 'balance')
            if balance['type'] == 'frozen':
                account['used'] = self.safe_string(balance, 'balance')
            result[code] = account
        return self.safe_balance(result)

# Instantiate for use in tests
bittrade = MockExchange()

# ------------------ UNIT TESTS ------------------

# 1. BASIC TEST CASES

def test_single_currency_trade_balance():
    # Covers: single currency, only 'trade' type (free)
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "0.5"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 11.9μs -> 12.1μs (1.29% slower)

def test_single_currency_frozen_balance():
    # Covers: single currency, only 'frozen' type (used)
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "frozen", "balance": "1.2"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 9.73μs -> 10.1μs (3.49% slower)

def test_single_currency_both_types():
    # Covers: single currency, both 'trade' and 'frozen'
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "0.7"},
                {"currency": "BTC", "type": "frozen", "balance": "0.3"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 13.2μs -> 13.3μs (0.511% slower)

def test_multiple_currencies():
    # Covers: multiple currencies, both types
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "1"},
                {"currency": "BTC", "type": "frozen", "balance": "2"},
                {"currency": "ETH", "type": "trade", "balance": "3"},
                {"currency": "ETH", "type": "frozen", "balance": "4"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 17.3μs -> 17.2μs (0.326% faster)

def test_currency_normalization():
    # Covers: currency normalization (e.g., XBT -> BTC)
    response = {
        "data": {
            "list": [
                {"currency": "XBT", "type": "trade", "balance": "0.1"},
                {"currency": "XBT", "type": "frozen", "balance": "0.2"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 14.6μs -> 14.5μs (0.822% faster)

# 2. EDGE TEST CASES

def test_empty_list():
    # Covers: empty balance list
    response = {"data": {"list": []}}
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 3.83μs -> 3.97μs (3.50% slower)


def test_missing_list_key():
    # Covers: missing 'list' key inside 'data'
    response = {"data": {}}
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 4.04μs -> 4.09μs (1.42% slower)

def test_zero_balances():
    # Covers: zero balances for both types
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "0"},
                {"currency": "BTC", "type": "frozen", "balance": "0"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 13.0μs -> 13.0μs (0.015% slower)

def test_negative_balances():
    # Covers: negative balances
    response = {
        "data": {
            "list": [
                {"currency": "ETH", "type": "trade", "balance": "-1.5"},
                {"currency": "ETH", "type": "frozen", "balance": "-0.5"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 13.0μs -> 12.8μs (2.20% faster)

def test_duplicate_entries_overwrite():
    # Covers: duplicate entries for the same type (should overwrite, last one wins)
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "1"},
                {"currency": "BTC", "type": "trade", "balance": "2"},  # should overwrite previous
                {"currency": "BTC", "type": "frozen", "balance": "3"},
                {"currency": "BTC", "type": "frozen", "balance": "4"}  # should overwrite previous
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 14.1μs -> 14.3μs (1.57% slower)

def test_missing_currency_field():
    # Covers: missing 'currency' field in a balance entry (should be skipped)
    response = {
        "data": {
            "list": [
                {"type": "trade", "balance": "1.2"},
                {"currency": "BTC", "type": "trade", "balance": "0.5"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 14.0μs -> 14.0μs (0.186% faster)

def test_missing_balance_field():
    # Covers: missing 'balance' field (should be ignored, free/used will be None)
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade"},
                {"currency": "BTC", "type": "frozen"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 10.4μs -> 10.4μs (0.144% slower)

def test_unknown_type_field():
    # Covers: unknown 'type' field (should be ignored)
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "unknown", "balance": "5"},
                {"currency": "BTC", "type": "trade", "balance": "1"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 10.4μs -> 10.5μs (0.945% slower)


def test_large_number_of_currencies():
    # Covers: performance and correctness with many currencies
    n = 500
    response = {
        "data": {
            "list": [
                {"currency": f"CUR{i}", "type": "trade", "balance": str(i)} for i in range(n)
            ] + [
                {"currency": f"CUR{i}", "type": "frozen", "balance": str(i*2)} for i in range(n)
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 1.96ms -> 1.95ms (0.739% faster)
    for i in range(n):
        code = f"CUR{i}"

def test_large_balances_and_precision():
    # Covers: large numbers and high precision floats
    response = {
        "data": {
            "list": [
                {"currency": "BTC", "type": "trade", "balance": "123456789.123456789"},
                {"currency": "BTC", "type": "frozen", "balance": "987654321.987654321"}
            ]
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 17.2μs -> 17.3μs (0.847% slower)


def test_large_input_with_duplicate_entries():
    # Covers: large input, duplicate entries for same currency/type (last one wins)
    n = 200
    response = {
        "data": {
            "list": (
                [{"currency": f"CUR{i}", "type": "trade", "balance": "1"} for i in range(n)] +
                [{"currency": f"CUR{i}", "type": "trade", "balance": "2"} for i in range(n)] +  # should overwrite
                [{"currency": f"CUR{i}", "type": "frozen", "balance": "3"} for i in range(n)] +
                [{"currency": f"CUR{i}", "type": "frozen", "balance": "4"} for i in range(n)]  # should overwrite
            )
        }
    }
    codeflash_output = bittrade.parse_balance(response); result = codeflash_output # 1.16ms -> 1.18ms (1.20% slower)
    for i in range(n):
        code = f"CUR{i}"
# 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_balance-mhx335ae and push.