⚡️ Speed up function to_hexstr by 28%

[codeflash-ai]

📄 28% (0.28x) speedup for to_hexstr in electrum/plugins/digitalbitbox/digitalbitbox.py

⏱️ Runtime : 51.1 microseconds → 40.0 microseconds (best of 250 runs)

📝 Explanation and details

The optimization leverages Python's built-in bytes.hex() method for the common case where the input is a bytes object, providing a 27% speedup.

Key Changes:

• Added a type check isinstance(s, bytes) to identify when the input is a bytes object
• For bytes inputs, use the native .hex() method instead of binascii.hexlify(s).decode('ascii')
• Fallback to the original binascii.hexlify() approach for other types like bytearray

Why It's Faster:
The bytes.hex() method is implemented in C and optimized specifically for converting bytes to hexadecimal strings, avoiding the overhead of:

1. Calling the binascii.hexlify() function
2. The additional .decode('ascii') step to convert bytes to string

Performance Impact:

• Bytes inputs (80% of test cases): 28-69% faster, with most cases showing 40-60% improvement
• Non-bytes inputs (bytearray, invalid types): 7-30% slower due to the added type check overhead
• Large data (1KB): 24-52% faster, showing the optimization scales well

The performance profile shows that 80% of calls (40 out of 50) take the fast path through s.hex(), making this optimization highly effective for the typical use case of converting bytes objects to hex strings in cryptocurrency/hardware wallet operations.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import binascii  # used in the function under test
import random  # used for generating large scale random data

# imports
import pytest  # used for our unit tests
from electrum.plugins.digitalbitbox.digitalbitbox import to_hexstr

# unit tests

# -------------------------------
# 1. Basic Test Cases
# -------------------------------

def test_basic_empty_bytes():
    # Test converting empty bytes
    codeflash_output = to_hexstr(b'') # 741ns -> 531ns (39.5% faster)

def test_basic_single_byte():
    # Test converting a single byte
    codeflash_output = to_hexstr(b'\x00') # 849ns -> 519ns (63.6% faster)
    codeflash_output = to_hexstr(b'\xff') # 400ns -> 270ns (48.1% faster)
    codeflash_output = to_hexstr(b'A') # 262ns -> 186ns (40.9% faster)

def test_basic_multiple_bytes():
    # Test converting multiple bytes
    codeflash_output = to_hexstr(b'\x01\x02\x03') # 875ns -> 524ns (67.0% faster)
    codeflash_output = to_hexstr(b'ABC') # 394ns -> 246ns (60.2% faster)
    codeflash_output = to_hexstr(b'\x10\x20\x30\x40') # 365ns -> 216ns (69.0% faster)

def test_basic_ascii_string_bytes():
    # Test ASCII string bytes
    codeflash_output = to_hexstr(b'hello') # 795ns -> 523ns (52.0% faster)

def test_basic_non_ascii_bytes():
    # Test non-ASCII bytes
    codeflash_output = to_hexstr(b'\x80\x90\xa0') # 817ns -> 505ns (61.8% faster)

# -------------------------------
# 2. Edge Test Cases
# -------------------------------

def test_edge_invalid_type():
    # Test passing non-bytes input (should raise TypeError)
    with pytest.raises(TypeError):
        to_hexstr('not bytes') # 1.42μs -> 1.74μs (18.5% slower)

    with pytest.raises(TypeError):
        to_hexstr(1234) # 833ns -> 922ns (9.65% slower)

    with pytest.raises(TypeError):
        to_hexstr([1,2,3]) # 624ns -> 677ns (7.83% slower)

def test_edge_bytearray_input():
    # Test bytearray input, which is accepted by binascii.hexlify
    codeflash_output = to_hexstr(bytearray([0x12, 0x34])) # 995ns -> 1.42μs (29.7% slower)


def test_edge_all_byte_values():
    # Test all possible byte values (0x00 to 0xFF)
    all_bytes = bytes(range(256))
    expected = ''.join(f'{i:02x}' for i in range(256))
    codeflash_output = to_hexstr(all_bytes) # 1.34μs -> 928ns (44.4% faster)

def test_edge_leading_zero_bytes():
    # Test bytes with leading zeros
    codeflash_output = to_hexstr(b'\x00\x01\x02') # 908ns -> 530ns (71.3% faster)

def test_edge_trailing_zero_bytes():
    # Test bytes with trailing zeros
    codeflash_output = to_hexstr(b'\x01\x02\x00') # 800ns -> 523ns (53.0% faster)

def test_edge_unicode_bytes():
    # Test bytes that represent unicode code points
    # e.g. the UTF-8 encoding of 'é' is b'\xc3\xa9'
    codeflash_output = to_hexstr('é'.encode('utf-8')) # 896ns -> 535ns (67.5% faster)

def test_edge_bytes_with_null():
    # Test bytes with null byte inside
    codeflash_output = to_hexstr(b'\x00hello\x00') # 893ns -> 545ns (63.9% faster)

def test_edge_large_single_value():
    # Test a large single value (e.g. 0xFF repeated)
    codeflash_output = to_hexstr(b'\xff' * 10) # 791ns -> 559ns (41.5% faster)

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

def test_large_scale_1000_bytes_all_zero():
    # Test with 1000 zero bytes
    data = b'\x00' * 1000
    expected = '00' * 1000
    codeflash_output = to_hexstr(data) # 2.20μs -> 1.46μs (51.5% faster)

def test_large_scale_1000_bytes_all_ff():
    # Test with 1000 bytes of 0xFF
    data = b'\xff' * 1000
    expected = 'ff' * 1000
    codeflash_output = to_hexstr(data) # 1.99μs -> 1.39μs (42.9% faster)

def test_large_scale_1000_bytes_increasing():
    # Test with 1000 bytes increasing from 0 to 255 repeatedly
    data = bytes([i % 256 for i in range(1000)])
    expected = ''.join(f'{i % 256:02x}' for i in range(1000))
    codeflash_output = to_hexstr(data) # 2.06μs -> 1.37μs (50.3% faster)

def test_large_scale_1000_bytes_random():
    # Test with 1000 random bytes
    random.seed(42)  # deterministic seed
    data = bytes(random.getrandbits(8) for _ in range(1000))
    expected = binascii.hexlify(data).decode('ascii')
    codeflash_output = to_hexstr(data) # 1.68μs -> 1.31μs (28.8% faster)

def test_large_scale_performance():
    # Test that large input does not take excessive time (should complete quickly)
    import time
    data = bytes([random.randint(0, 255) for _ in range(1000)])
    start = time.time()
    codeflash_output = to_hexstr(data); result = codeflash_output # 1.95μs -> 1.34μs (46.0% faster)
    end = time.time()
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import binascii  # used in the function under test

# imports
import pytest  # used for our unit tests
from electrum.plugins.digitalbitbox.digitalbitbox import to_hexstr

# unit tests

# 1. Basic Test Cases

def test_basic_ascii_bytes():
    # Test with simple ASCII bytes
    codeflash_output = to_hexstr(b'abc') # 1.12μs -> 661ns (69.1% faster)
    codeflash_output = to_hexstr(b'123') # 389ns -> 248ns (56.9% faster)
    codeflash_output = to_hexstr(b'hello') # 357ns -> 228ns (56.6% faster)

def test_basic_empty_bytes():
    # Test with empty bytes object
    codeflash_output = to_hexstr(b'') # 723ns -> 552ns (31.0% faster)

def test_basic_single_byte():
    # Test with single byte values
    codeflash_output = to_hexstr(b'\x00') # 885ns -> 529ns (67.3% faster)
    codeflash_output = to_hexstr(b'\xff') # 377ns -> 248ns (52.0% faster)
    codeflash_output = to_hexstr(b'A') # 250ns -> 189ns (32.3% faster)

def test_basic_mixed_bytes():
    # Test with a mix of ASCII and non-ASCII bytes
    codeflash_output = to_hexstr(b'\x00\xff\x10\x41') # 838ns -> 525ns (59.6% faster)

# 2. Edge Test Cases

def test_edge_non_ascii_bytes():
    # Test with bytes that are not ASCII (e.g., 0x80-0xFF)
    codeflash_output = to_hexstr(b'\x80\x90\xfe\xff') # 839ns -> 506ns (65.8% faster)

def test_edge_all_byte_values():
    # Test with all possible byte values (0x00 to 0xFF)
    all_bytes = bytes(range(256))
    expected = ''.join(f'{i:02x}' for i in range(256))
    codeflash_output = to_hexstr(all_bytes) # 1.33μs -> 819ns (63.0% faster)

def test_edge_large_single_value():
    # Test with a long sequence of the same byte
    b = b'\xaa' * 100
    codeflash_output = to_hexstr(b) # 980ns -> 635ns (54.3% faster)

def test_edge_non_bytes_input():
    # Test that function raises TypeError for non-bytes input (e.g., string, int, list)
    with pytest.raises(TypeError):
        to_hexstr('abc') # 1.43μs -> 1.81μs (20.9% slower)
    with pytest.raises(TypeError):
        to_hexstr(123) # 825ns -> 950ns (13.2% slower)
    with pytest.raises(TypeError):
        to_hexstr([0x61, 0x62, 0x63]) # 606ns -> 699ns (13.3% slower)

def test_edge_bytearray_input():
    # Test that bytearray is accepted (since binascii.hexlify supports it)
    codeflash_output = to_hexstr(bytearray(b'abc')) # 1.15μs -> 1.50μs (23.3% slower)


def test_edge_unicode_bytes():
    # Test with bytes from a UTF-8 encoded string with non-ASCII characters
    s = '你好'.encode('utf-8')  # b'\xe4\xbd\xa0\xe5\xa5\xbd'
    codeflash_output = to_hexstr(s) # 863ns -> 647ns (33.4% faster)

def test_edge_bytes_with_nulls():
    # Test with bytes containing null bytes
    b = b'\x00hello\x00world\x00'
    codeflash_output = to_hexstr(b) # 929ns -> 576ns (61.3% faster)

# 3. Large Scale Test Cases

def test_large_1k_bytes():
    # Test with a 1000-byte array of incremental values
    data = bytes([i % 256 for i in range(1000)])
    expected = ''.join(f'{i % 256:02x}' for i in range(1000))
    codeflash_output = to_hexstr(data) # 2.13μs -> 1.47μs (45.0% faster)

def test_large_all_same_byte():
    # Test with a 1000-byte array of the same value
    data = b'\x7f' * 1000
    expected = '7f' * 1000
    codeflash_output = to_hexstr(data) # 2.02μs -> 1.49μs (35.6% faster)

def test_large_random_bytes():
    # Test with 1000 random bytes (deterministic for test)
    import random
    random.seed(0)
    data = bytes([random.randint(0, 255) for _ in range(1000)])
    expected = binascii.hexlify(data).decode('ascii')
    codeflash_output = to_hexstr(data) # 1.67μs -> 1.34μs (24.0% faster)

def test_large_performance():
    # Test that function completes for large input (not a strict timing test)
    data = b'\xff' * 999
    codeflash_output = to_hexstr(data); result = codeflash_output # 2.00μs -> 1.41μs (41.4% faster)

# 4. Additional Robustness Cases

def test_edge_bytes_with_high_bit_set():
    # Test with bytes where the highest bit is set
    b = bytes([0b10000000, 0b11111111])
    codeflash_output = to_hexstr(b) # 899ns -> 554ns (62.3% faster)

def test_edge_bytes_with_alternating_bits():
    # Test with alternating bit patterns
    b = bytes([0b10101010, 0b01010101])
    codeflash_output = to_hexstr(b) # 881ns -> 526ns (67.5% faster)

def test_edge_bytes_with_leading_zero():
    # Test with bytes that have leading zeros
    b = b'\x00\x01\x02'
    codeflash_output = to_hexstr(b) # 864ns -> 541ns (59.7% faster)
# 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-to_hexstr-mhp0wo1x and push.