⚡️ Speed up function get_abuffer_desc by 34%

[codeflash-ai]

📄 34% (0.34x) speedup for get_abuffer_desc in src/spdl/io/_preprocessing.py

⏱️ Runtime : 815 microseconds → 610 microseconds (best of 78 runs)

📝 Explanation and details

The optimized version achieves a 33% speedup by eliminating the intermediate list creation and join() operation used in the original code.

Key optimizations:

1. Direct f-string concatenation: Instead of creating a list of 4 f-strings and joining them with :, the optimized version constructs the entire args string in one f-string expression with embedded colons.

2. Eliminated temporary allocations: The original code allocated a 4-element list and then called join() on it, creating multiple temporary objects. The optimized version creates the final string directly.

3. Conditional return optimization: Rather than always creating a name variable and then formatting it into the final string, the optimized version uses an if-else block to return the appropriate format directly, avoiding one extra string formatting operation when label is None.

Why this is faster:

• Python's join() method on lists requires iteration over the list elements and concatenation, while a single f-string is compiled into more efficient bytecode
• Fewer temporary objects means less memory allocation and garbage collection overhead
• Direct conditional returns eliminate unnecessary string interpolation

The optimization is particularly effective for the test cases shown, providing 24-51% speedup across various scenarios, with the best improvements seen when dealing with empty strings or special characters where string operations are most costly.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import pytest
from spdl.io._preprocessing import get_abuffer_desc


# function to test
class AudioCodec:
    """
    Minimal mock of spdl.io.AudioCodec for testing purposes.
    """
    def __init__(self, time_base, sample_rate, sample_fmt, channel_layout):
        self.time_base = time_base  # tuple (num, den)
        self.sample_rate = sample_rate  # int
        self.sample_fmt = sample_fmt  # str
        self.channel_layout = channel_layout  # str
from spdl.io._preprocessing import get_abuffer_desc

# unit tests

# --- Basic Test Cases ---

def test_basic_no_label_no_sample_fmt():
    # Typical usage, all fields set, no label or sample_fmt override
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 2.41μs -> 1.75μs (37.5% faster)

def test_basic_with_label():
    # Label provided, should appear in output
    codec = AudioCodec(time_base=(1, 44100), sample_rate=44100, sample_fmt="s16", channel_layout="mono")
    codeflash_output = get_abuffer_desc(codec, label="input1"); result = codeflash_output # 2.50μs -> 1.75μs (42.8% faster)

def test_basic_with_sample_fmt_override():
    # sample_fmt provided, should override codec.sample_fmt
    codec = AudioCodec(time_base=(1001, 48000), sample_rate=48000, sample_fmt="dbl", channel_layout="5.1")
    codeflash_output = get_abuffer_desc(codec, sample_fmt="s32"); result = codeflash_output # 2.23μs -> 1.68μs (32.8% faster)

def test_basic_with_label_and_sample_fmt_override():
    # Both label and sample_fmt provided
    codec = AudioCodec(time_base=(1, 96000), sample_rate=96000, sample_fmt="u8", channel_layout="quad")
    codeflash_output = get_abuffer_desc(codec, label="abc", sample_fmt="flt"); result = codeflash_output # 2.29μs -> 1.65μs (38.9% faster)

# --- Edge Test Cases ---

def test_edge_time_base_zero_denominator():
    # Edge: denominator is zero (should still format, but may not be valid for ffmpeg)
    codec = AudioCodec(time_base=(1, 0), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 2.00μs -> 1.37μs (46.6% faster)

def test_edge_time_base_zero_numerator():
    # Edge: numerator is zero
    codec = AudioCodec(time_base=(0, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 1.85μs -> 1.39μs (33.3% faster)

def test_edge_negative_time_base():
    # Negative numerator and denominator
    codec = AudioCodec(time_base=(-1, -48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 2.01μs -> 1.42μs (40.9% faster)

def test_edge_sample_rate_zero():
    # Edge: sample_rate is zero
    codec = AudioCodec(time_base=(1, 48000), sample_rate=0, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 1.85μs -> 1.39μs (33.6% faster)

def test_edge_sample_fmt_empty_string():
    # Edge: sample_fmt is empty string, and not overridden
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 1.85μs -> 1.26μs (46.4% faster)

def test_edge_channel_layout_empty_string():
    # Edge: channel_layout is empty string
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 1.83μs -> 1.20μs (52.9% faster)

def test_edge_label_empty_string():
    # Edge: label is empty string (should still format as abuffer@)
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec, label=""); result = codeflash_output # 2.27μs -> 1.70μs (33.2% faster)

def test_edge_sample_fmt_override_empty_string():
    # sample_fmt override is empty string, should use empty string
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    codeflash_output = get_abuffer_desc(codec, sample_fmt=""); result = codeflash_output # 2.07μs -> 1.60μs (29.4% faster)

def test_edge_label_special_characters():
    # Label with special characters
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    label = "foo@bar:123"
    codeflash_output = get_abuffer_desc(codec, label=label); result = codeflash_output # 2.14μs -> 1.62μs (32.6% faster)

def test_edge_sample_fmt_override_special_characters():
    # sample_fmt override with special characters
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    sample_fmt = "weird:fmt@123"
    codeflash_output = get_abuffer_desc(codec, sample_fmt=sample_fmt); result = codeflash_output # 2.02μs -> 1.52μs (32.8% faster)

def test_edge_large_numbers():
    # Very large sample_rate and time_base values
    codec = AudioCodec(time_base=(2**31-1, 2**31-1), sample_rate=2**31-1, sample_fmt="s64", channel_layout="huge")
    codeflash_output = get_abuffer_desc(codec); result = codeflash_output # 2.03μs -> 1.53μs (32.7% faster)

def test_edge_all_empty_strings():
    # All string fields empty, label and sample_fmt override as empty
    codec = AudioCodec(time_base=(0, 0), sample_rate=0, sample_fmt="", channel_layout="")
    codeflash_output = get_abuffer_desc(codec, label="", sample_fmt=""); result = codeflash_output # 2.16μs -> 1.60μs (34.7% faster)

# --- Large Scale Test Cases ---

def test_large_scale_many_codecs_unique():
    # Test with many different codecs, all unique
    for i in range(100):
        codec = AudioCodec(time_base=(i+1, 1000+i), sample_rate=44100+i, sample_fmt=f"f{i}", channel_layout=f"layout{i}")
        label = f"l{i}"
        sample_fmt = f"sf{i}"
        codeflash_output = get_abuffer_desc(codec, label=label, sample_fmt=sample_fmt); result = codeflash_output # 69.2μs -> 52.3μs (32.3% faster)
        expected = f"abuffer@{label}=time_base={i+1}/{1000+i}:sample_rate={44100+i}:sample_fmt={sample_fmt}:channel_layout=layout{i}"

def test_large_scale_long_strings():
    # Test with long strings for label, sample_fmt, and channel_layout
    long_label = "L" * 500
    long_sample_fmt = "F" * 500
    long_channel_layout = "C" * 500
    codec = AudioCodec(time_base=(123, 456), sample_rate=78910, sample_fmt="orig", channel_layout=long_channel_layout)
    codeflash_output = get_abuffer_desc(codec, label=long_label, sample_fmt=long_sample_fmt); result = codeflash_output # 2.90μs -> 1.93μs (50.7% faster)
    expected = f"abuffer@{long_label}=time_base=123/456:sample_rate=78910:sample_fmt={long_sample_fmt}:channel_layout={long_channel_layout}"

def test_large_scale_many_invocations_performance():
    # Ensure function is performant under many invocations (not measured, but should not error)
    codec = AudioCodec(time_base=(1, 48000), sample_rate=48000, sample_fmt="fltp", channel_layout="stereo")
    for i in range(1000):
        label = f"label{i}"
        sample_fmt = f"fmt{i}"
        codeflash_output = get_abuffer_desc(codec, label=label, sample_fmt=sample_fmt); desc = codeflash_output # 659μs -> 492μs (33.8% faster)

def test_large_scale_all_combinations():
    # Test all combinations of label/sample_fmt present or not, for a batch of codecs
    codecs = [
        AudioCodec(time_base=(1, 2), sample_rate=3, sample_fmt="a", channel_layout="x"),
        AudioCodec(time_base=(4, 5), sample_rate=6, sample_fmt="b", channel_layout="y"),
        AudioCodec(time_base=(7, 8), sample_rate=9, sample_fmt="c", channel_layout="z"),
    ]
    for i, codec in enumerate(codecs):
        # No label, no sample_fmt
        codeflash_output = get_abuffer_desc(codec) # 3.53μs -> 2.67μs (31.9% faster)
        # Label only
        codeflash_output = get_abuffer_desc(codec, label=f"lab{i}")
        # sample_fmt only
        codeflash_output = get_abuffer_desc(codec, sample_fmt=f"sf{i}") # 2.93μs -> 2.36μs (24.2% faster)
        # Both
        codeflash_output = get_abuffer_desc(codec, label=f"lab{i}", sample_fmt=f"sf{i}")

# --- Determinism Test ---

def test_determinism_same_input_same_output():
    # For identical input, output should always be the same
    codec = AudioCodec(time_base=(1, 2), sample_rate=3, sample_fmt="a", channel_layout="b")
    codeflash_output = get_abuffer_desc(codec, label="foo", sample_fmt="bar"); out1 = codeflash_output # 1.79μs -> 1.26μs (41.5% faster)
    codeflash_output = get_abuffer_desc(codec, label="foo", sample_fmt="bar"); out2 = codeflash_output # 931ns -> 699ns (33.2% faster)

# --- Type Robustness Test ---

def test_type_error_on_missing_codec_fields():
    # If codec is missing required fields, should raise AttributeError
    class BadCodec:
        pass
    bad_codec = BadCodec()
    with pytest.raises(AttributeError):
        get_abuffer_desc(bad_codec) # 1.53μs -> 1.16μs (32.4% faster)
# 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 spdl.io._preprocessing import get_abuffer_desc


# Mock AudioCodec class for testing purposes
class AudioCodec:
    def __init__(self, time_base, sample_rate, sample_fmt, channel_layout):
        self.time_base = time_base  # tuple (numerator, denominator)
        self.sample_rate = sample_rate  # int
        self.sample_fmt = sample_fmt  # str
        self.channel_layout = channel_layout  # str
from spdl.io._preprocessing import get_abuffer_desc

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

def test_basic_no_label_no_sample_fmt():
    # Basic case: all fields present, no label, no override
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.87μs -> 1.52μs (23.4% faster)

def test_basic_with_label():
    # Basic case: label provided, no sample_fmt override
    codec = AudioCodec((1, 44100), 44100, "s16", "mono")
    codeflash_output = get_abuffer_desc(codec, label="input1"); desc = codeflash_output # 2.19μs -> 1.64μs (33.6% faster)

def test_basic_with_sample_fmt_override():
    # Basic case: sample_fmt override provided
    codec = AudioCodec((1001, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, sample_fmt="s32"); desc = codeflash_output # 2.17μs -> 1.55μs (39.8% faster)

def test_basic_with_label_and_sample_fmt():
    # Both label and sample_fmt override provided
    codec = AudioCodec((1, 16000), 16000, "s16p", "5.1")
    codeflash_output = get_abuffer_desc(codec, label="main", sample_fmt="flt"); desc = codeflash_output # 2.14μs -> 1.65μs (30.0% faster)

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

def test_edge_time_base_zero_denominator():
    # Edge: denominator zero (invalid in practice, but test for string formatting)
    codec = AudioCodec((1, 0), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.84μs -> 1.47μs (24.6% faster)

def test_edge_time_base_zero_numerator():
    # Edge: numerator zero
    codec = AudioCodec((0, 44100), 44100, "s16", "mono")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.85μs -> 1.35μs (37.4% faster)

def test_edge_empty_label():
    # Edge: empty string as label
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, label=""); desc = codeflash_output # 2.15μs -> 1.72μs (24.9% faster)

def test_edge_empty_sample_fmt():
    # Edge: empty string as sample_fmt (should override to empty)
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, sample_fmt=""); desc = codeflash_output # 2.03μs -> 1.58μs (28.3% faster)

def test_edge_channel_layout_empty():
    # Edge: empty channel_layout
    codec = AudioCodec((1, 48000), 48000, "fltp", "")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.81μs -> 1.35μs (33.6% faster)

def test_edge_all_empty_strings():
    # Edge: all string fields empty
    codec = AudioCodec((0, 0), 0, "", "")
    codeflash_output = get_abuffer_desc(codec, label="", sample_fmt=""); desc = codeflash_output # 2.22μs -> 1.64μs (35.7% faster)

def test_edge_large_label():
    # Edge: very long label
    long_label = "a" * 256
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, label=long_label); desc = codeflash_output # 2.20μs -> 1.69μs (30.5% faster)

def test_edge_label_special_chars():
    # Edge: label with special characters
    special_label = "in@put#1:!"
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, label=special_label); desc = codeflash_output # 2.03μs -> 1.55μs (30.5% faster)

def test_edge_sample_fmt_special_chars():
    # Edge: sample_fmt with special characters
    special_fmt = "f@lt#"
    codec = AudioCodec((1, 48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec, sample_fmt=special_fmt); desc = codeflash_output # 2.04μs -> 1.59μs (28.0% faster)

def test_edge_time_base_negative():
    # Edge: negative time_base values
    codec = AudioCodec((-1, -48000), 48000, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.95μs -> 1.51μs (29.2% faster)

def test_edge_sample_rate_zero():
    # Edge: sample_rate zero
    codec = AudioCodec((1, 48000), 0, "fltp", "stereo")
    codeflash_output = get_abuffer_desc(codec); desc = codeflash_output # 1.80μs -> 1.35μs (34.0% faster)

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






#------------------------------------------------
from spdl.io._preprocessing import get_abuffer_desc
from spdl.io._type_stub import AudioCodec
import pytest

def test_get_abuffer_desc():
    with pytest.raises(TypeError, match="'NoneType'\\ object\\ is\\ not\\ subscriptable"):
        get_abuffer_desc(AudioCodec(), label='', sample_fmt='')

def test_get_abuffer_desc_2():
    with pytest.raises(TypeError, match="'NoneType'\\ object\\ is\\ not\\ subscriptable"):
        get_abuffer_desc(AudioCodec(), label=None, sample_fmt='')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_uafn4wd5/tmpx9g8f3tg/test_concolic_coverage.py::test_get_abuffer_desc	2.24μs	1.93μs	16.1%✅
codeflash_concolic_uafn4wd5/tmpx9g8f3tg/test_concolic_coverage.py::test_get_abuffer_desc_2	1.70μs	1.50μs	12.7%✅

To edit these changes git checkout codeflash/optimize-get_abuffer_desc-mgraemec and push.