⚡️ Speed up function to_hexstr by 15%

[codeflash-ai]

📄 15% (0.15x) speedup for to_hexstr in electrum/plugins/digitalbitbox/digitalbitbox.py

⏱️ Runtime : 48.1 microseconds → 41.9 microseconds (best of 496 runs)

📝 Explanation and details

The optimization introduces a fast path for the most common input types: bytes and bytearray. Instead of always using binascii.hexlify().decode('ascii'), the code now first checks if the input is a bytes or bytearray object and uses Python's built-in .hex() method directly.

Key optimizations:

1. Direct .hex() method: For bytes and bytearray inputs, the native .hex() method is significantly faster than the binascii.hexlify().decode('ascii') chain
2. Type-based branching: The type(s) is bytes or type(s) is bytearray check adds minimal overhead while enabling the fast path

Why this is faster:

• The .hex() method is implemented in C and avoids the intermediate bytes object creation and ASCII decoding step
• From the line profiler, 59 out of 68 calls (87%) take the fast path using .hex() with 772.6ns per hit vs 1310ns per hit for the fallback
• Only 9 calls use the slower fallback path for non-bytes/bytearray inputs

Performance characteristics:

• Best case scenarios: Simple bytes inputs show 20-40% speedups, with some cases like b'\xde\xad\xbe\xef' showing 57% improvement
• Large data: 1000-byte inputs show 17-40% speedups, making this optimization particularly valuable for cryptocurrency applications that process large binary data
• Edge cases: Non-bytes inputs are 5-30% slower due to the type check overhead, but these are exceptional cases that should raise TypeError anyway

The 14% overall speedup comes primarily from the common case where input is already bytes/bytearray, which represents the vast majority of real-world usage in a hardware wallet plugin.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import binascii  # used for reference implementation and error checking
import random  # used for generating large random byte strings

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

# unit tests

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

def test_empty_bytes():
    # Test conversion of empty bytes
    codeflash_output = to_hexstr(b'') # 657ns -> 605ns (8.60% faster)

def test_single_byte():
    # Test conversion of single byte
    codeflash_output = to_hexstr(b'\x00') # 703ns -> 530ns (32.6% faster)
    codeflash_output = to_hexstr(b'\xff') # 314ns -> 236ns (33.1% faster)
    codeflash_output = to_hexstr(b'\x7f') # 218ns -> 160ns (36.2% faster)

def test_multiple_bytes():
    # Test conversion of multiple bytes
    codeflash_output = to_hexstr(b'\x01\x02\x03') # 650ns -> 504ns (29.0% faster)
    codeflash_output = to_hexstr(b'\xde\xad\xbe\xef') # 377ns -> 240ns (57.1% faster)
    codeflash_output = to_hexstr(b'\x10\x20\x30\x40\x50') # 271ns -> 194ns (39.7% faster)

def test_ascii_bytes():
    # Test conversion of ASCII bytes
    codeflash_output = to_hexstr(b'abc') # 626ns -> 496ns (26.2% faster)
    codeflash_output = to_hexstr(b'123') # 275ns -> 225ns (22.2% faster)

def test_uppercase_vs_lowercase():
    # Ensure output is always lowercase
    codeflash_output = to_hexstr(b'\xAA\xBB\xCC') # 581ns -> 442ns (31.4% faster)

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

def test_non_bytes_input():
    # Test that non-bytes input raises TypeError
    with pytest.raises(TypeError):
        to_hexstr('not bytes') # 1.20μs -> 1.61μs (25.5% slower)
    with pytest.raises(TypeError):
        to_hexstr(123) # 691ns -> 767ns (9.91% slower)
    with pytest.raises(TypeError):
        to_hexstr([1,2,3]) # 526ns -> 608ns (13.5% slower)
    with pytest.raises(TypeError):
        to_hexstr(None) # 498ns -> 528ns (5.68% slower)

def test_all_byte_values():
    # Test conversion of all possible byte values (0x00 to 0xFF)
    all_bytes = bytes(range(256))
    expected = ''.join('{:02x}'.format(i) for i in range(256))
    codeflash_output = to_hexstr(all_bytes) # 1.14μs -> 860ns (32.7% faster)

def test_high_bit_bytes():
    # Test conversion of bytes with high bit set
    codeflash_output = to_hexstr(b'\x80\x90\xA0\xB0\xC0\xD0\xE0\xF0') # 661ns -> 538ns (22.9% faster)

def test_leading_zero_bytes():
    # Test conversion of bytes with leading zeros
    codeflash_output = to_hexstr(b'\x00\x01\x02') # 672ns -> 514ns (30.7% faster)
    codeflash_output = to_hexstr(b'\x00\x00\xff') # 286ns -> 197ns (45.2% faster)

def test_trailing_zero_bytes():
    # Test conversion of bytes with trailing zeros
    codeflash_output = to_hexstr(b'\xff\x00\x00') # 637ns -> 477ns (33.5% faster)

def test_bytes_with_non_ascii():
    # Test conversion of bytes that are not valid ASCII
    codeflash_output = to_hexstr(b'\x80\xff\xfe') # 627ns -> 457ns (37.2% faster)

def test_bytes_with_null():
    # Test conversion of bytes containing null byte
    codeflash_output = to_hexstr(b'\x00abc\x00') # 674ns -> 502ns (34.3% faster)

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

def test_large_random_bytes():
    # Test conversion of a large random byte string (1000 bytes)
    data = bytes(random.getrandbits(8) for _ in range(1000))
    expected = binascii.hexlify(data).decode('ascii')
    codeflash_output = to_hexstr(data) # 1.38μs -> 1.17μs (17.8% faster)

def test_large_repeating_bytes():
    # Test conversion of a large repeating byte string
    data = b'\xAB' * 1000
    expected = 'ab' * 1000
    codeflash_output = to_hexstr(data) # 1.64μs -> 1.23μs (32.8% faster)

def test_large_all_byte_values():
    # Test conversion of multiple repetitions of all byte values
    data = bytes(range(256)) * 3  # 768 bytes
    expected = ''.join('{:02x}'.format(i) for i in range(256)) * 3
    codeflash_output = to_hexstr(data) # 1.43μs -> 1.05μs (35.2% faster)

def test_large_empty_bytes():
    # Test conversion of large empty byte string (edge case for size 0)
    codeflash_output = to_hexstr(b'') # 593ns -> 502ns (18.1% faster)

def test_large_bytes_performance():
    # Test conversion of a large byte string (999 bytes, near limit)
    data = bytes([0x55, 0xAA] * 499) + b'\xFF'
    expected = binascii.hexlify(data).decode('ascii')
    codeflash_output = to_hexstr(data) # 1.28μs -> 1.19μs (7.37% faster)

# -----------------------
# 4. Mutation Sensitivity Tests
# -----------------------

def test_mutation_sensitivity():
    # Ensure that changing any byte changes the output at the expected position
    original = b'\x00\x01\x02\x03'
    mutated = b'\x00\x01\x02\x04'
    codeflash_output = to_hexstr(original) # 668ns -> 521ns (28.2% faster)
    # Ensure that swapping bytes changes output
    swapped = b'\x03\x02\x01\x00'
    codeflash_output = to_hexstr(original) # 280ns -> 198ns (41.4% faster)

def test_output_length():
    # Output string should be exactly twice the length of the input bytes
    for length in [0, 1, 10, 100, 999]:
        data = bytes([0x42] * length)
        codeflash_output = len(to_hexstr(data)) # 2.81μs -> 2.00μs (40.5% faster)

def test_output_is_ascii():
    # Output should only contain ASCII characters 0-9 and a-f
    data = bytes(range(256))
    codeflash_output = to_hexstr(data); hexstr = codeflash_output # 937ns -> 690ns (35.8% faster)
    allowed = set('0123456789abcdef')
# 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 to test
import random  # used for generating large scale test data

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

# unit tests

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

def test_basic_empty_bytes():
    # Test with empty bytes input
    codeflash_output = to_hexstr(b'') # 579ns -> 500ns (15.8% faster)

def test_basic_ascii_bytes():
    # Test with simple ASCII bytes
    codeflash_output = to_hexstr(b'abc') # 608ns -> 514ns (18.3% faster)
    codeflash_output = to_hexstr(b'123') # 287ns -> 235ns (22.1% faster)
    codeflash_output = to_hexstr(b'hello world') # 290ns -> 188ns (54.3% faster)

def test_basic_non_ascii_bytes():
    # Test with bytes containing non-ASCII values
    codeflash_output = to_hexstr(b'\x00\xff\x10') # 591ns -> 478ns (23.6% faster)
    codeflash_output = to_hexstr(b'\x7f\x80\xfe') # 279ns -> 210ns (32.9% faster)

def test_basic_single_byte():
    # Test with a single byte
    codeflash_output = to_hexstr(b'\x01') # 577ns -> 487ns (18.5% faster)
    codeflash_output = to_hexstr(b'\xff') # 282ns -> 231ns (22.1% faster)

def test_basic_all_bytes():
    # 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) # 944ns -> 713ns (32.4% faster)

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

def test_edge_input_type_bytes():
    # Ensure only bytes-like objects are accepted
    with pytest.raises(TypeError):
        to_hexstr('string') # 1.12μs -> 1.60μs (30.0% slower)

    with pytest.raises(TypeError):
        to_hexstr(123) # 639ns -> 761ns (16.0% slower)

    with pytest.raises(TypeError):
        to_hexstr(None) # 523ns -> 613ns (14.7% slower)

def test_edge_unicode_bytes():
    # Test with bytes representing valid UTF-8 but input is bytes
    utf8_bytes = '你好'.encode('utf-8')
    # Should return the hex representation of the bytes
    codeflash_output = to_hexstr(utf8_bytes) # 712ns -> 593ns (20.1% faster)

def test_edge_zero_bytes():
    # Test with bytes containing only zeros
    codeflash_output = to_hexstr(b'\x00\x00\x00') # 670ns -> 513ns (30.6% faster)

def test_edge_max_byte_value():
    # Test with bytes containing only 0xff
    codeflash_output = to_hexstr(b'\xff\xff\xff') # 619ns -> 479ns (29.2% faster)

def test_edge_alternating_bytes():
    # Test with alternating 0x00 and 0xff
    codeflash_output = to_hexstr(b'\x00\xff\x00\xff') # 640ns -> 499ns (28.3% faster)

def test_edge_bytes_with_special_characters():
    # Test with bytes that would be special in ASCII
    special_bytes = b'\n\r\t\x00'
    codeflash_output = to_hexstr(special_bytes) # 647ns -> 509ns (27.1% faster)

def test_edge_large_single_byte():
    # Test with a byte value at the edge of the valid range
    codeflash_output = to_hexstr(bytes([255])) # 672ns -> 512ns (31.2% faster)
    codeflash_output = to_hexstr(bytes([0])) # 270ns -> 225ns (20.0% faster)


def test_large_scale_1000_bytes():
    # Test with 1000 random bytes
    data = bytes(random.getrandbits(8) for _ in range(1000))
    # The output should match the hex representation of the input
    codeflash_output = to_hexstr(data) # 1.64μs -> 1.28μs (27.8% faster)

def test_large_scale_repeated_pattern():
    # Test with a repeated pattern to ensure output is correct
    pattern = b'\x01\x02\x03\x04'
    data = pattern * 250  # 4*250 = 1000 bytes
    expected = pattern.hex() * 250
    codeflash_output = to_hexstr(data) # 1.60μs -> 1.14μs (39.7% faster)

def test_large_scale_all_byte_values_repeated():
    # Test with all byte values repeated several times
    data = bytes(range(256)) * 3  # 768 bytes
    expected = ''.join(f'{i:02x}' for i in range(256)) * 3
    codeflash_output = to_hexstr(data) # 1.40μs -> 1.08μs (29.2% faster)


def test_large_scale_bytearray():
    # Test with a large bytearray object
    data = bytearray([random.randint(0, 255) for _ in range(999)])
    codeflash_output = to_hexstr(data) # 1.74μs -> 1.45μs (20.4% faster)

# ---------------------------
# Mutation Testing Guards
# ---------------------------

def test_mutation_guard_case_sensitivity():
    # Should always return lowercase hex
    codeflash_output = to_hexstr(b'\xab\xcd\xef') # 652ns -> 548ns (19.0% faster)
    # If function mutates to upper case, this will fail

def test_mutation_guard_output_type():
    # Should always return a string, not bytes
    codeflash_output = to_hexstr(b'abc'); result = codeflash_output # 637ns -> 512ns (24.4% faster)

def test_mutation_guard_no_extra_characters():
    # Should not include spaces, colons, or other separators
    codeflash_output = to_hexstr(b'\x01\x23\x45') # 645ns -> 507ns (27.2% faster)

def test_mutation_guard_correct_length():
    # Output string should be exactly twice the length of input bytes
    for n in [0, 1, 10, 100, 999]:
        data = bytes([random.randint(0, 255) for _ in range(n)])
        codeflash_output = len(to_hexstr(data)) # 2.90μs -> 2.04μs (42.0% 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-mhctddr0 and push.