⚡️ Speed up method hyperliquid.parse_market by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for hyperliquid.parse_market in python/ccxt/async_support/hyperliquid.py

⏱️ Runtime : 24.4 milliseconds → 23.1 milliseconds (best of 59 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup primarily through string processing optimizations and reduced function call overhead in the calculate_price_precision method, which represents a significant portion of the runtime (17.1% in the original vs 15.7% in the optimized).

Key optimizations applied:

1. Fast-path string comparisons: Replaced expensive Precise.string_eq(priceStr, '0') calls with direct string equality checks (priceStr == '0'), eliminating costly object instantiation for common cases.

2. Optimized loop elimination in parse_precision: The original code used explicit loops to build precision strings ('0.' + '0' * (precisionNumber - 1) + '1'). The optimized version uses string multiplication, which is significantly faster in Python - reducing parse_precision time from 3.82ms to 2.09ms (45% improvement).

3. Leading zero counting optimization: For numbers between 0 and 1, replaced manual character-by-character loop with len(decimalPart) - len(decimalPart.lstrip('0')), leveraging Python's optimized C-level string operations.

4. Reduced function call overhead: Cached frequently-called constants like self.safe_currency_code('USDC') to avoid redundant lookups, and constructed precision/limits dictionaries directly rather than through repeated method calls.

5. Early returns: Added fast-path early returns in calculate_price_precision to avoid expensive Precise operations when simple string checks suffice.

Impact on workloads: The optimizations are particularly effective for test cases involving small prices (0 < price < 1) and high-precision calculations, showing 28-34% improvements for such cases. The gains are less pronounced but still consistent (5-11%) for typical market parsing scenarios, making this beneficial for high-frequency market data processing where parse_market is called repeatedly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import decimal

# imports
import pytest
from ccxt.async_support.hyperliquid import hyperliquid


def number_to_string(x):
    if x is None:
        return None
    d = decimal.Decimal(str(x))
    formatted = '{:f}'.format(d)
    return formatted.rstrip('0').rstrip('.') if '.' in formatted else formatted
from ccxt.async_support.hyperliquid import hyperliquid

# --- Unit tests for hyperliquid.parse_market ---

@pytest.fixture
def hl():
    return hyperliquid()

# 1. Basic Test Cases

def test_parse_market_basic(hl):
    # Standard ETH market
    market = {
        "maxLeverage": "50",
        "name": "ETH",
        "baseId": "ETH",
        "szDecimals": "4",
        "markPx": "2369.6"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 66.7μs -> 65.9μs (1.22% faster)

def test_parse_market_basic_btc(hl):
    # BTC market, different decimals
    market = {
        "maxLeverage": "100",
        "name": "BTC",
        "baseId": "BTC",
        "szDecimals": "3",
        "markPx": "30000.0"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 62.0μs -> 61.7μs (0.603% faster)

def test_parse_market_basic_small_price(hl):
    # Market with small markPx, e.g. SHIB
    market = {
        "maxLeverage": "10",
        "name": "SHIB",
        "baseId": "SHIB",
        "szDecimals": "0",
        "markPx": "0.00001234"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 66.9μs -> 50.7μs (32.0% faster)

def test_parse_market_basic_delisted(hl):
    # Market with isDelisted True
    market = {
        "maxLeverage": "25",
        "name": "DOGE",
        "baseId": "DOGE",
        "szDecimals": "2",
        "markPx": "0.12",
        "isDelisted": True
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 64.5μs -> 48.1μs (34.0% faster)

def test_parse_market_basic_not_delisted(hl):
    # Market with isDelisted False
    market = {
        "maxLeverage": "25",
        "name": "DOGE",
        "baseId": "DOGE",
        "szDecimals": "2",
        "markPx": "0.12",
        "isDelisted": False
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 64.0μs -> 48.2μs (32.8% faster)

# 2. Edge Test Cases

def test_parse_market_missing_markPx(hl):
    # markPx missing, should use default 0
    market = {
        "maxLeverage": "5",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "1"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 51.1μs -> 45.8μs (11.5% faster)

def test_parse_market_markPx_zero(hl):
    # markPx is zero string
    market = {
        "maxLeverage": "1",
        "name": "ZERO",
        "baseId": "ZERO",
        "szDecimals": "2",
        "markPx": "0"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 51.9μs -> 47.2μs (9.85% faster)

def test_parse_market_markPx_one(hl):
    # markPx is 1
    market = {
        "maxLeverage": "3",
        "name": "ONE",
        "baseId": "ONE",
        "szDecimals": "2",
        "markPx": "1"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 59.8μs -> 60.2μs (0.595% slower)

def test_parse_market_markPx_less_than_one(hl):
    # markPx between 0 and 1, e.g. 0.01
    market = {
        "maxLeverage": "2",
        "name": "LESS",
        "baseId": "LESS",
        "szDecimals": "2",
        "markPx": "0.01"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 62.8μs -> 48.8μs (28.7% faster)

def test_parse_market_missing_szDecimals(hl):
    # szDecimals missing: should raise
    market = {
        "maxLeverage": "10",
        "name": "FOO",
        "baseId": "FOO",
        "markPx": "1.23"
    }
    with pytest.raises(TypeError):
        hl.parse_market(market) # 25.8μs -> 26.0μs (0.950% slower)

def test_parse_market_non_numeric_szDecimals(hl):
    # szDecimals not a number: should raise
    market = {
        "maxLeverage": "10",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "foo",
        "markPx": "1.23"
    }
    with pytest.raises(ValueError):
        hl.parse_market(market) # 27.0μs -> 27.7μs (2.34% slower)


def test_parse_market_missing_baseId(hl):
    # baseId missing: should be None in output
    market = {
        "maxLeverage": "10",
        "name": "FOO",
        "szDecimals": "2",
        "markPx": "1.23"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 67.9μs -> 67.4μs (0.706% faster)

def test_parse_market_missing_maxLeverage(hl):
    # maxLeverage missing: limits.leverage.max should be None
    market = {
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "2",
        "markPx": "1.23"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 65.2μs -> 64.7μs (0.751% faster)

def test_parse_market_non_numeric_maxLeverage(hl):
    # maxLeverage not a number: limits.leverage.max should be None
    market = {
        "maxLeverage": "foo",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "2",
        "markPx": "1.23"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 66.0μs -> 65.4μs (0.856% faster)

def test_parse_market_fees_missing(hl):
    # fees missing from self.fees['swap']
    hl.fees = {}  # remove fees
    market = {
        "maxLeverage": "5",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "1",
        "markPx": "1.0"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 58.0μs -> 57.3μs (1.24% faster)

def test_parse_market_fees_partial(hl):
    # Only taker fee present in fees
    hl.fees = {'swap': {'taker': '0.001'}}
    market = {
        "maxLeverage": "5",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "1",
        "markPx": "1.0"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 56.7μs -> 57.9μs (2.14% slower)

def test_parse_market_markPx_high_precision(hl):
    # markPx with many decimals
    market = {
        "maxLeverage": "10",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "2",
        "markPx": "0.00000012345678"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 68.8μs -> 51.6μs (33.2% faster)

def test_parse_market_markPx_large_integer(hl):
    # markPx is a large integer
    market = {
        "maxLeverage": "10",
        "name": "FOO",
        "baseId": "FOO",
        "szDecimals": "2",
        "markPx": "123456789"
    }
    codeflash_output = hl.parse_market(market); result = codeflash_output # 61.8μs -> 62.0μs (0.250% slower)

# 3. Large Scale Test Cases

def test_parse_market_large_scale_unique(hl):
    # 1000 unique markets, all should parse uniquely
    markets = []
    for i in range(1000):
        markets.append({
            "maxLeverage": str(1 + (i % 100)),
            "name": f"COIN{i}",
            "baseId": f"COIN{i}",
            "szDecimals": str(i % 6),
            "markPx": str(0.0001 * (i+1))
        })
    results = [hl.parse_market(m) for m in markets]
    # All symbols should be unique and match format
    symbols = set()
    for i, res in enumerate(results):
        symbols.add(res['symbol'])
        # Check amount precision is correct
        expected_amount_prec = float('1' if int(markets[i]['szDecimals']) == 0 else '0.' + '0' * (int(markets[i]['szDecimals']) - 1) + '1')

def test_parse_market_large_scale_varied_prices(hl):
    # 500 markets with varied markPx, check price precision is always <= 1
    for i in range(500):
        markPx = 10 ** (i % 7) * (1 + (i % 3) * 0.1234)
        szDecimals = str((i % 6))
        market = {
            "maxLeverage": str(1 + (i % 50)),
            "name": f"VAR{i}",
            "baseId": f"VAR{i}",
            "szDecimals": szDecimals,
            "markPx": str(markPx)
        }
        codeflash_output = hl.parse_market(market); res = codeflash_output # 14.0ms -> 13.3ms (5.26% faster)

def test_parse_market_large_scale_active_delisted(hl):
    # 200 markets, alternate isDelisted True/False, check activeness
    for i in range(200):
        isDelisted = (i % 2 == 0)
        market = {
            "maxLeverage": "10",
            "name": f"DEL{i}",
            "baseId": f"DEL{i}",
            "szDecimals": "2",
            "markPx": "1.0",
            "isDelisted": isDelisted
        }
        codeflash_output = hl.parse_market(market); res = codeflash_output # 4.94ms -> 4.66ms (6.02% faster)

def test_parse_market_large_scale_missing_fields(hl):
    # 100 markets missing some optional fields
    for i in range(100):
        market = {
            "name": f"MISS{i}",
            "szDecimals": str(i % 6),
            "markPx": str(0.1 * (i+1))
        }
        codeflash_output = hl.parse_market(market); res = codeflash_output # 2.87ms -> 2.66ms (7.88% faster)

def test_parse_market_large_scale_extreme_decimals(hl):
    # 50 markets with szDecimals from 0 to 10, ensure correct amount precision
    for i in range(0, 11):
        market = {
            "name": f"DEC{i}",
            "baseId": f"DEC{i}",
            "szDecimals": str(i),
            "markPx": "1.0"
        }
        codeflash_output = hl.parse_market(market); res = codeflash_output # 328μs -> 314μs (4.41% faster)
        if i == 0:
            pass
        else:
            expected = float('0.' + '0' * (i-1) + '1')
# 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.async_support.hyperliquid import hyperliquid

# --- Minimal stub for hyperliquid.parse_market and dependencies ---
# We'll define only the necessary parts for the tests to run.

class DummyExchange:
    # Minimal stub for currency code normalization
    def __init__(self):
        self.fees = {
            'swap': {
                'taker': 0.0005,
                'maker': 0.0003,
            }
        }
        self.currencies_by_id = None  # not used in our stub
        self.currencies = {}

    def safe_string(self, d, k, default=None):
        return str(d[k]) if k in d and d[k] is not None else default

    def safe_currency_code(self, code, currency=None):
        # For this stub, just return the code uppercased, except for XBT, BCHSV
        if code is None:
            return None
        code = code.upper()
        if code == "XBT":
            return "BTC"
        if code == "BCHSV":
            return "BSV"
        return code

    def safe_dict(self, d, k, default=None):
        return d.get(k, default) if isinstance(d, dict) else default

    def safe_number(self, d, k, default=None):
        try:
            return float(d[k])
        except (KeyError, TypeError, ValueError):
            return default

    def safe_bool(self, d, k, default=None):
        v = d.get(k, default)
        if isinstance(v, bool):
            return v
        return default

    def safe_integer(self, d, k, default=None):
        try:
            return int(float(d[k]))
        except (KeyError, TypeError, ValueError):
            return default

    def parse_number(self, v, default=None):
        try:
            return float(v)
        except Exception:
            return default

    def number_to_string(self, x):
        if x is None:
            return None
        s = str(x)
        if '.' in s:
            s = s.rstrip('0').rstrip('.')
        return s

    def parse_precision(self, precision):
        if precision is None:
            return None
        p = int(precision)
        if p == 0:
            return '1'
        if p > 0:
            return '0.' + '0' * (p - 1) + '1'
        else:
            return '1' + '0' * (-p) + '0'

    def parse_to_int(self, number):
        return int(float(self.number_to_string(number)))

    def safe_market_structure(self, market):
        # Just return the dict as is for testing
        return market

    def calculate_price_precision(self, price, amountPrecision, maxDecimals):
        # Implement the logic as in the real code
        pricePrecision = 0
        priceStr = self.number_to_string(price)
        if priceStr is None:
            return 0
        priceSplitted = priceStr.split('.')
        if priceStr == '0':
            significantDigits = 5
            integerDigits = 0
            pricePrecision = min(maxDecimals - amountPrecision, significantDigits - integerDigits)
        elif float(priceStr) > 0 and float(priceStr) < 1:
            significantDigits = 5
            decimalPart = priceSplitted[1] if len(priceSplitted) > 1 else ''
            leadingZeros = 0
            for c in decimalPart:
                if c == '0':
                    leadingZeros += 1
                else:
                    break
            pricePrecision = leadingZeros + significantDigits
            pricePrecision = min(maxDecimals - amountPrecision, pricePrecision)
        else:
            integerPart = priceSplitted[0]
            significantDigits = max(5, len(integerPart))
            pricePrecision = min(maxDecimals - amountPrecision, significantDigits - len(integerPart))
        return self.parse_to_int(pricePrecision)

    def parse_market(self, market):
        quoteId = 'USDC'
        baseName = self.safe_string(market, 'name')
        base = self.safe_currency_code(baseName)
        quote = self.safe_currency_code(quoteId)
        baseId = self.safe_string(market, 'baseId')
        settleId = 'USDC'
        settle = self.safe_currency_code(settleId)
        symbol = base + '/' + quote
        contract = True
        swap = True
        if contract:
            if swap:
                symbol = symbol + ':' + settle
        fees = self.safe_dict(self.fees, 'swap', {})
        taker = self.safe_number(fees, 'taker')
        maker = self.safe_number(fees, 'maker')
        amountPrecisionStr = self.safe_string(market, 'szDecimals')
        amountPrecision = int(amountPrecisionStr)
        price = self.safe_number(market, 'markPx', 0)
        pricePrecision = 0
        if price is not None:
            pricePrecision = self.calculate_price_precision(price, amountPrecision, 6)
        pricePrecisionStr = self.number_to_string(pricePrecision)
        isDelisted = self.safe_bool(market, 'isDelisted')
        active = True
        if isDelisted is not None:
            active = not isDelisted
        return self.safe_market_structure({
            'id': baseId,
            'symbol': symbol,
            'base': base,
            'quote': quote,
            'settle': settle,
            'baseId': baseId,
            'baseName': baseName,
            'quoteId': quoteId,
            'settleId': settleId,
            'type': 'swap',
            'spot': False,
            'margin': None,
            'swap': swap,
            'future': False,
            'option': False,
            'active': active,
            'contract': contract,
            'linear': True,
            'inverse': False,
            'taker': taker,
            'maker': maker,
            'contractSize': self.parse_number('1'),
            'expiry': None,
            'expiryDatetime': None,
            'strike': None,
            'optionType': None,
            'precision': {
                'amount': self.parse_number(self.parse_precision(amountPrecisionStr)),
                'price': self.parse_number(self.parse_precision(pricePrecisionStr)),
            },
            'limits': {
                'leverage': {
                    'min': None,
                    'max': self.safe_integer(market, 'maxLeverage'),
                },
                'amount': {
                    'min': None,
                    'max': None,
                },
                'price': {
                    'min': None,
                    'max': None,
                },
                'cost': {
                    'min': self.parse_number('10'),
                    'max': None,
                },
            },
            'created': None,
            'info': market,
        })

# The function under test
hyperliquid = DummyExchange()

# --- Unit tests for hyperliquid.parse_market ---

# 1. Basic Test Cases

def test_basic_eth_market():
    # Typical ETH/USDC swap market
    market = {
        "maxLeverage": "50",
        "name": "ETH",
        "baseId": "ETH",
        "szDecimals": "4",
        "markPx": "2369.6"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 16.7μs -> 17.1μs (2.73% slower)

def test_basic_btc_market():
    # BTC market, different decimals
    market = {
        "maxLeverage": "100",
        "name": "BTC",
        "baseId": "BTC",
        "szDecimals": "3",
        "markPx": "65000.123"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 14.9μs -> 14.8μs (0.372% faster)

def test_basic_with_markPx_zero():
    # markPx=0
    market = {
        "maxLeverage": "10",
        "name": "SOL",
        "baseId": "SOL",
        "szDecimals": "2",
        "markPx": "0"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 12.5μs -> 12.6μs (1.32% slower)

def test_basic_with_missing_markPx():
    # markPx missing, should default to 0
    market = {
        "maxLeverage": "5",
        "name": "AVAX",
        "baseId": "AVAX",
        "szDecimals": "2"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 11.8μs -> 11.9μs (0.958% slower)

def test_basic_with_isDelisted_false():
    # isDelisted False
    market = {
        "maxLeverage": "5",
        "name": "DOGE",
        "baseId": "DOGE",
        "szDecimals": "3",
        "markPx": "0.123",
        "isDelisted": False
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 13.4μs -> 13.9μs (4.16% slower)

def test_basic_with_isDelisted_true():
    # isDelisted True
    market = {
        "maxLeverage": "5",
        "name": "DOGE",
        "baseId": "DOGE",
        "szDecimals": "3",
        "markPx": "0.123",
        "isDelisted": True
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 13.4μs -> 13.2μs (1.67% faster)

# 2. Edge Test Cases

def test_edge_zero_szDecimals():
    # szDecimals = 0
    market = {
        "maxLeverage": "1",
        "name": "USDT",
        "baseId": "USDT",
        "szDecimals": "0",
        "markPx": "1"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 12.9μs -> 12.5μs (3.30% faster)

def test_edge_price_less_than_one_many_leading_zeros():
    # price < 1 with many leading zeros
    market = {
        "maxLeverage": "2",
        "name": "SHIB",
        "baseId": "SHIB",
        "szDecimals": "5",
        "markPx": "0.00001234"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 14.8μs -> 15.0μs (1.60% slower)

def test_edge_price_is_none():
    # markPx is None
    market = {
        "maxLeverage": "2",
        "name": "UNI",
        "baseId": "UNI",
        "szDecimals": "2",
        "markPx": None
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 12.5μs -> 12.4μs (1.13% faster)

def test_edge_non_string_szDecimals():
    # szDecimals as int
    market = {
        "maxLeverage": "10",
        "name": "LINK",
        "baseId": "LINK",
        "szDecimals": 3,
        "markPx": "7.123"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 13.1μs -> 13.4μs (2.22% slower)

def test_edge_symbol_normalization():
    # XBT and BCHSV normalization
    market_xbt = {
        "maxLeverage": "50",
        "name": "XBT",
        "baseId": "XBT",
        "szDecimals": "4",
        "markPx": "50000"
    }
    codeflash_output = hyperliquid.parse_market(market_xbt); parsed_xbt = codeflash_output # 12.4μs -> 12.9μs (3.70% slower)

    market_bchsv = {
        "maxLeverage": "10",
        "name": "BCHSV",
        "baseId": "BCHSV",
        "szDecimals": "2",
        "markPx": "100"
    }
    codeflash_output = hyperliquid.parse_market(market_bchsv); parsed_bchsv = codeflash_output # 8.29μs -> 8.46μs (1.95% slower)

def test_edge_missing_baseId():
    # baseId missing
    market = {
        "maxLeverage": "10",
        "name": "MATIC",
        "szDecimals": "2",
        "markPx": "1.23"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 12.3μs -> 12.6μs (2.24% slower)

def test_edge_missing_szDecimals():
    # szDecimals missing: should raise ValueError
    market = {
        "maxLeverage": "10",
        "name": "ADA",
        "baseId": "ADA",
        "markPx": "1.23"
    }
    with pytest.raises(TypeError):
        hyperliquid.parse_market(market) # 4.08μs -> 4.23μs (3.71% slower)

def test_edge_szDecimals_negative():
    # szDecimals negative: should parse as negative precision
    market = {
        "maxLeverage": "10",
        "name": "NEG",
        "baseId": "NEG",
        "szDecimals": "-2",
        "markPx": "1.23"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 13.6μs -> 13.9μs (2.03% slower)

def test_edge_maxLeverage_non_numeric():
    # maxLeverage is non-numeric
    market = {
        "maxLeverage": "abc",
        "name": "ZZZ",
        "baseId": "ZZZ",
        "szDecimals": "2",
        "markPx": "1"
    }
    codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 14.1μs -> 14.1μs (0.608% slower)



def test_large_scale_extreme_prices():
    # Markets with extremely large and small markPx
    market_large = {
        "maxLeverage": "100",
        "name": "BIG",
        "baseId": "BIG",
        "szDecimals": "2",
        "markPx": "1000000000"
    }
    codeflash_output = hyperliquid.parse_market(market_large); parsed_large = codeflash_output # 17.9μs -> 18.6μs (3.71% slower)

    market_small = {
        "maxLeverage": "100",
        "name": "SMALL",
        "baseId": "SMALL",
        "szDecimals": "6",
        "markPx": "0.000000123"
    }
    codeflash_output = hyperliquid.parse_market(market_small); parsed_small = codeflash_output # 11.8μs -> 12.2μs (3.41% slower)

def test_large_scale_all_isDelisted():
    # 100 markets, all delisted
    for i in range(100):
        market = {
            "maxLeverage": "1",
            "name": f"DLT{i}",
            "baseId": f"DLT{i}",
            "szDecimals": "2",
            "markPx": "1.0",
            "isDelisted": True
        }
        codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 488μs -> 492μs (0.709% slower)

def test_large_scale_randomized_inputs():
    # 100 markets with randomized szDecimals, markPx, maxLeverage, isDelisted
    import random
    for i in range(100):
        szDecimals = str(random.randint(0, 6))
        markPx = str(random.uniform(0, 100000))
        maxLeverage = str(random.choice([1, 10, 50, 100, 200]))
        isDelisted = random.choice([True, False, None])
        market = {
            "maxLeverage": maxLeverage,
            "name": f"RAND{i}",
            "baseId": f"RAND{i}",
            "szDecimals": szDecimals,
            "markPx": markPx,
        }
        if isDelisted is not None:
            market["isDelisted"] = isDelisted
        codeflash_output = hyperliquid.parse_market(market); parsed = codeflash_output # 566μs -> 575μs (1.53% slower)
        # Active flag
        if isDelisted is not None:
            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-hyperliquid.parse_market-mhzprq9a and push.