⚡️ Speed up function convert_bytes by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for convert_bytes in src/together/utils/tools.py

⏱️ Runtime : 6.64 milliseconds → 6.17 milliseconds (best of 131 runs)

📝 Explanation and details

The optimization replaces the slower "{:.1f} {}".format(num, unit) string formatting method with the faster f-string syntax f"{num:.1f} {unit}". This single change results in a 7% overall speedup.

Key Performance Improvement:

• F-strings are significantly faster than .format() method calls because they're evaluated at compile-time rather than runtime, avoiding the overhead of method dispatch and argument parsing that .format() requires.

Why This Works:
The line profiler shows that the string formatting line (line with the return statement) drops from 497.8ns per hit to 452.3ns per hit - a 9% improvement on that specific operation. Since this line is executed 12,317 times in the profiling run, this micro-optimization compounds to meaningful performance gains.

Test Case Performance:
The optimization shows consistent improvements across all test scenarios:

• Best gains on simple conversions like single bytes and boolean inputs (up to 42% faster for True input)
• Consistent gains across different unit scales (KB, MB, GB, TB, PB) averaging 5-15% improvement
• Batch operations benefit significantly, with the large-scale test showing 7.6% improvement when processing 1000 values
• Even edge cases like negative values and large floats see 3-12% improvements

The f-string syntax maintains identical functionality and output format while providing this performance boost through more efficient string interpolation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

# imports
import pytest  # used for our unit tests
from together.utils.tools import convert_bytes

# unit tests

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

def test_bytes_basic_single_byte():
    # Test with exactly 1 byte
    codeflash_output = convert_bytes(1) # 2.22μs -> 1.84μs (20.5% faster)

def test_bytes_basic_under_1kb():
    # Test with a value less than 1024 (should be in bytes)
    codeflash_output = convert_bytes(512) # 1.48μs -> 1.43μs (3.92% faster)

def test_bytes_basic_exact_1kb():
    # Test with exactly 1024 bytes (should be 1.0 KB)
    codeflash_output = convert_bytes(1024) # 1.77μs -> 1.65μs (7.71% faster)

def test_bytes_basic_fractional_kb():
    # Test with a value between 1 KB and 2 KB
    codeflash_output = convert_bytes(1536) # 1.63μs -> 1.56μs (5.01% faster)

def test_bytes_basic_exact_1mb():
    # Test with exactly 1 MB
    codeflash_output = convert_bytes(1024 * 1024) # 1.71μs -> 1.63μs (4.97% faster)

def test_bytes_basic_exact_1gb():
    # Test with exactly 1 GB
    codeflash_output = convert_bytes(1024 ** 3) # 2.04μs -> 1.91μs (7.08% faster)

def test_bytes_basic_exact_1tb():
    # Test with exactly 1 TB
    codeflash_output = convert_bytes(1024 ** 4) # 1.87μs -> 1.73μs (8.03% faster)

def test_bytes_basic_exact_1pb():
    # Test with exactly 1 PB
    codeflash_output = convert_bytes(1024 ** 5) # 1.85μs -> 1.67μs (10.5% faster)

def test_bytes_basic_fractional_mb():
    # Test with a value between 1 MB and 2 MB
    codeflash_output = convert_bytes(1.5 * 1024 * 1024) # 1.57μs -> 1.45μs (8.58% faster)

def test_bytes_basic_float_input():
    # Test with a float value that is not an integer
    codeflash_output = convert_bytes(123.456) # 1.38μs -> 1.23μs (11.7% faster)

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

def test_bytes_edge_zero_bytes():
    # Test with zero bytes
    codeflash_output = convert_bytes(0) # 1.47μs -> 1.49μs (0.941% slower)

def test_bytes_edge_negative_bytes():
    # Test with a negative value (should still format as bytes)
    codeflash_output = convert_bytes(-1024) # 1.50μs -> 1.39μs (7.89% faster)

def test_bytes_edge_just_below_unit_threshold():
    # Test with values just below each threshold
    codeflash_output = convert_bytes(1023) # 1.54μs -> 1.44μs (6.86% faster)
    codeflash_output = convert_bytes(1024*1024 - 1) # 1.11μs -> 1.06μs (5.10% faster)
    codeflash_output = convert_bytes(1024**2 * 1024 - 1) # 636ns -> 650ns (2.15% slower)
    codeflash_output = convert_bytes(1024**3 * 1024 - 1) # 853ns -> 836ns (2.03% faster)
    codeflash_output = convert_bytes(1024**4 * 1024 - 1) # 627ns -> 632ns (0.791% slower)

def test_bytes_edge_just_above_unit_threshold():
    # Test with values just above each threshold
    codeflash_output = convert_bytes(1024 + 1) # 1.45μs -> 1.38μs (5.16% faster)
    codeflash_output = convert_bytes(1024*1024 + 1) # 730ns -> 725ns (0.690% faster)
    codeflash_output = convert_bytes(1024**3 + 1) # 740ns -> 723ns (2.35% faster)
    codeflash_output = convert_bytes(1024**4 + 1) # 588ns -> 595ns (1.18% slower)
    codeflash_output = convert_bytes(1024**5 + 1) # 658ns -> 644ns (2.17% faster)

def test_bytes_edge_large_float():
    # Test with a large float value that is not an integer
    codeflash_output = convert_bytes(1234567890.123) # 1.46μs -> 1.36μs (6.59% faster)

def test_bytes_edge_nan_and_inf():
    # Test with NaN and infinity
    import math
    codeflash_output = convert_bytes(float('nan')) # 760ns -> 796ns (4.52% slower)
    codeflash_output = convert_bytes(float('inf')) # 437ns -> 439ns (0.456% slower)
    codeflash_output = convert_bytes(float('-inf')) # 1.12μs -> 903ns (23.6% faster)

def test_bytes_edge_none_input():
    # Test with None input (should raise TypeError)
    with pytest.raises(TypeError):
        convert_bytes(None) # 1.54μs -> 1.60μs (3.68% slower)

def test_bytes_edge_non_numeric_input():
    # Test with string input (should raise TypeError)
    with pytest.raises(TypeError):
        convert_bytes("1024") # 1.47μs -> 1.47μs (0.204% slower)

def test_bytes_edge_bool_input():
    # Test with boolean input (should treat True as 1, False as 0)
    codeflash_output = convert_bytes(True) # 2.46μs -> 1.72μs (42.5% faster)
    codeflash_output = convert_bytes(False) # 818ns -> 736ns (11.1% faster)

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

def test_bytes_large_scale_max_pb():
    # Test with a value just below the PB threshold
    codeflash_output = convert_bytes(1024**6 - 1) # 1.31μs -> 1.35μs (2.82% slower)

def test_bytes_large_scale_over_pb():
    # Test with a value above the PB threshold (should return None)
    codeflash_output = convert_bytes(1024**6) # 1.07μs -> 1.02μs (4.79% faster)
    codeflash_output = convert_bytes(1024**7) # 538ns -> 547ns (1.65% slower)

def test_bytes_large_scale_many_values():
    # Test with a range of values from 0 to 1024**6 in steps
    # This checks for performance and correctness across a large range
    for i in range(0, 1024**6, 1024**5 // 10):  # 10 steps per PB
        codeflash_output = convert_bytes(i); result = codeflash_output # 5.58ms -> 5.18ms (7.79% faster)
        # All results should be a string except for i == 1024**6
        if i < 1024**6:
            pass
        else:
            pass

def test_bytes_large_scale_large_float_precision():
    # Test with very large float values to check precision
    codeflash_output = convert_bytes(1.23456789e12) # 2.72μs -> 2.17μs (25.5% faster)
    codeflash_output = convert_bytes(9.87654321e15) # 795ns -> 783ns (1.53% faster)

def test_bytes_large_scale_performance():
    # Test performance with a list of 1000 large values
    values = [1024**5 + i * 1024**4 for i in range(1000)]
    for v in values:
        # All should return "PB" representation, except those exceeding the PB threshold
        codeflash_output = convert_bytes(v); result = codeflash_output # 546μs -> 507μs (7.66% faster)
        if v < 1024**6:
            pass
        else:
            pass

# -----------------------
# MUTATION TESTING CASES
# -----------------------

def test_bytes_mutation_testing():
    # If the function mutates the order of units, results should fail
    # This test ensures the units are applied in the correct order
    for num, expected in [
        (1024, "1.0 KB"),
        (1024**2, "1.0 MB"),
        (1024**3, "1.0 GB"),
        (1024**4, "1.0 TB"),
        (1024**5, "1.0 PB"),
    ]:
        codeflash_output = convert_bytes(num) # 5.06μs -> 4.46μs (13.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

# imports
import pytest  # used for our unit tests
from together.utils.tools import convert_bytes

# unit tests

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

def test_zero_bytes():
    # 0 bytes should be formatted as '0.0 B'
    codeflash_output = convert_bytes(0) # 1.94μs -> 1.74μs (11.9% faster)

def test_single_byte():
    # 1 byte should be formatted as '1.0 B'
    codeflash_output = convert_bytes(1) # 1.53μs -> 1.39μs (10.5% faster)

def test_under_one_kilobyte():
    # 512 bytes should be formatted as '512.0 B'
    codeflash_output = convert_bytes(512) # 1.52μs -> 1.37μs (10.7% faster)

def test_exactly_one_kilobyte():
    # 1024 bytes should be formatted as '1.0 KB'
    codeflash_output = convert_bytes(1024) # 1.65μs -> 1.59μs (3.85% faster)

def test_just_below_one_megabyte():
    # 1024*1024 - 1 bytes should be just below 1 MB, so should be in KB
    num = 1024 * 1024 - 1
    expected = "{:.1f} KB".format(num / 1024)
    codeflash_output = convert_bytes(num) # 1.19μs -> 1.24μs (4.11% slower)

def test_exactly_one_megabyte():
    # 1024*1024 bytes should be formatted as '1.0 MB'
    codeflash_output = convert_bytes(1024*1024) # 1.54μs -> 1.62μs (4.63% slower)

def test_fractional_kilobytes():
    # 1536 bytes = 1.5 KB
    codeflash_output = convert_bytes(1536) # 1.55μs -> 1.43μs (8.09% faster)

def test_fractional_megabytes():
    # 2.5 MB = 2.5 * 1024 * 1024 bytes
    num = 2.5 * 1024 * 1024
    codeflash_output = convert_bytes(num) # 1.52μs -> 1.40μs (8.64% faster)

def test_gigabytes():
    # 1073741824 bytes = 1 GB
    codeflash_output = convert_bytes(1073741824) # 2.04μs -> 1.90μs (7.37% faster)

def test_terabytes():
    # 1099511627776 bytes = 1 TB
    codeflash_output = convert_bytes(1099511627776) # 1.89μs -> 1.73μs (9.00% faster)

def test_petabytes():
    # 1125899906842624 bytes = 1 PB
    codeflash_output = convert_bytes(1125899906842624) # 1.86μs -> 1.72μs (7.97% faster)

def test_fractional_terabytes():
    # 1.5 TB = 1.5 * 1024 ** 4
    num = 1.5 * (1024 ** 4)
    codeflash_output = convert_bytes(num) # 1.58μs -> 1.41μs (12.1% faster)

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

def test_negative_bytes():
    # Negative bytes: should still format as B, but negative
    codeflash_output = convert_bytes(-1) # 1.56μs -> 1.63μs (4.47% slower)
    codeflash_output = convert_bytes(-1024) # 694ns -> 669ns (3.74% faster)

def test_float_input():
    # Float input: should format correctly
    codeflash_output = convert_bytes(1234.56) # 1.39μs -> 1.33μs (4.20% faster)
    # Float just below a unit
    codeflash_output = convert_bytes(1023.99) # 698ns -> 722ns (3.32% slower)

def test_large_float_input():
    # Large float input, between MB and GB
    num = 1.5 * 1024 * 1024 * 1024  # 1.5 GB
    codeflash_output = convert_bytes(num) # 1.51μs -> 1.42μs (6.32% faster)

def test_non_integer_input():
    # Input is a float less than 1 KB
    codeflash_output = convert_bytes(0.5) # 1.18μs -> 1.07μs (10.8% faster)

def test_return_none_above_petabytes():
    # Input larger than the largest unit (PB) should return None
    # 1 PB = 1024 TB = 1024*1024*1024*1024*1024 bytes
    # 2 PB = 2 * 1024**5
    num = 2 * 1024 ** 5
    codeflash_output = convert_bytes(num) # 2.08μs -> 1.99μs (4.32% faster)

def test_very_small_float():
    # Small float less than 1
    codeflash_output = convert_bytes(0.0001) # 1.55μs -> 1.46μs (6.02% faster)

def test_boundary_values():
    # Exactly at each boundary
    codeflash_output = convert_bytes(1024**2 - 1) # 1.71μs -> 1.70μs (0.529% faster)
    codeflash_output = convert_bytes(1024**3 - 1) # 847ns -> 843ns (0.474% faster)
    codeflash_output = convert_bytes(1024**4 - 1) # 892ns -> 824ns (8.25% faster)
    codeflash_output = convert_bytes(1024**5 - 1) # 658ns -> 631ns (4.28% faster)

def test_nan_and_inf():
    # NaN and inf should return None because they don't compare normally
    import math
    codeflash_output = convert_bytes(float('inf')) # 762ns -> 842ns (9.50% slower)
    codeflash_output = convert_bytes(float('-inf')) # 1.10μs -> 1.03μs (6.82% faster)
    codeflash_output = convert_bytes(float('nan')) # 385ns -> 402ns (4.23% slower)

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

def test_large_scale_bytes():
    # Test a range of increasing values up to PB, spot check outputs
    units = ["B", "KB", "MB", "GB", "TB", "PB"]
    for i, unit in enumerate(units):
        num = 1.23 * (1024 ** i)
        expected = "1.2 {}".format(unit)
        codeflash_output = convert_bytes(num) # 3.95μs -> 3.91μs (1.13% faster)

def test_large_batch_of_values():
    # Test a batch of random values in all units, within 1000 elements
    for i in range(0, 1000, 100):
        num = i * 1024
        if num < 1024:
            expected = "{:.1f} B".format(num)
        elif num < 1024**2:
            expected = "{:.1f} KB".format(num / 1024)
        elif num < 1024**3:
            expected = "{:.1f} MB".format(num / 1024**2)
        elif num < 1024**4:
            expected = "{:.1f} GB".format(num / 1024**3)
        elif num < 1024**5:
            expected = "{:.1f} TB".format(num / 1024**4)
        else:
            expected = "{:.1f} PB".format(num / 1024**5)
        # For num == 0, expected is '0.0 B'
        codeflash_output = convert_bytes(num) # 5.01μs -> 5.07μs (1.20% slower)

def test_performance_large_input():
    # Test performance with a large, but not excessive, value
    num = 999 * (1024 ** 5)  # 999 PB, within the PB range
    codeflash_output = convert_bytes(num) # 1.91μs -> 1.84μs (3.91% faster)

def test_performance_many_calls():
    # Test calling the function many times in a loop (1000 times)
    for i in range(1000):
        num = i * 1024
        # Just check that it does not raise and returns a string or None
        codeflash_output = convert_bytes(num); result = codeflash_output # 411μs -> 382μs (7.57% faster)

# ---------------------
# ADDITIONAL EDGE CASES
# ---------------------

def test_none_input():
    # None input should raise TypeError
    with pytest.raises(TypeError):
        convert_bytes(None) # 1.69μs -> 1.75μs (3.31% slower)

def test_string_input():
    # String input should raise TypeError
    with pytest.raises(TypeError):
        convert_bytes("1024") # 1.41μs -> 1.45μs (2.69% slower)

def test_list_input():
    # List input should raise TypeError
    with pytest.raises(TypeError):
        convert_bytes([1024]) # 1.35μs -> 1.39μs (2.24% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from together.utils.tools import convert_bytes

def test_convert_bytes():
    convert_bytes(1024.0)

def test_convert_bytes_2():
    convert_bytes(float('inf'))

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_atws5rsq/tmp42oakbmd/test_concolic_coverage.py::test_convert_bytes	1.26μs	1.20μs	4.93%✅
codeflash_concolic_atws5rsq/tmp42oakbmd/test_concolic_coverage.py::test_convert_bytes_2	798ns	831ns	-3.97%⚠️

To edit these changes git checkout codeflash/optimize-convert_bytes-mgzqw2sp and push.