⚡️ Speed up function get_buffer_desc by 19%

[codeflash-ai]

📄 19% (0.19x) speedup for get_buffer_desc in src/spdl/io/_preprocessing.py

⏱️ Runtime : 298 microseconds → 251 microseconds (best of 13 runs)

📝 Explanation and details

The optimization replaces a str.join() call with list creation overhead with a single f-string concatenation, yielding an 18% speedup.

Key changes:

1. Eliminated str.join() overhead: The original code created a list of 4 f-strings and then joined them with :, requiring list allocation and the join method call. The optimized version uses one continuous f-string with embedded colons.

2. Pre-computed pix_fmt_val: Instead of using pix_fmt or codec.pix_fmt inside the f-string (which evaluates the or operation during string formatting), the value is pre-computed once and reused.

Why this is faster:

• Reduced function calls: Eliminates the join() method call and list creation overhead
• Single string formatting operation: Python's f-string implementation is highly optimized for single concatenations vs. multiple string operations
• Avoids repeated boolean evaluation: The pix_fmt or codec.pix_fmt expression is evaluated once instead of during string formatting

Performance characteristics:
The optimization shows consistent 6-35% improvements across test cases, with the best gains on simpler codecs (fewer attribute accesses) and cases with empty/default values. The speedup is particularly effective for high-frequency usage scenarios, as evidenced by the large-scale test showing 17.6% improvement over 100 iterations.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 276 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_buffer_desc


# --- Begin function to test ---
# Minimal stubs for VideoCodec and ImageCodec for testing
class VideoCodec:
    def __init__(self, width, height, pix_fmt, time_base, sample_aspect_ratio):
        self.width = width
        self.height = height
        self.pix_fmt = pix_fmt
        self.time_base = time_base
        self.sample_aspect_ratio = sample_aspect_ratio

class ImageCodec:
    def __init__(self, width, height, pix_fmt, time_base, sample_aspect_ratio):
        self.width = width
        self.height = height
        self.pix_fmt = pix_fmt
        self.time_base = time_base
        self.sample_aspect_ratio = sample_aspect_ratio
from spdl.io._preprocessing import \
    get_buffer_desc  # --- End function to test ---

# --- Begin unit tests ---

# 1. Basic Test Cases

def test_basic_video_codec_default_pix_fmt():
    """Basic: Standard VideoCodec, no label, no pix_fmt override."""
    codec = VideoCodec(1920, 1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.62μs -> 2.00μs (30.6% faster)
    expected = "buffer=video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_basic_image_codec_with_label():
    """Basic: Standard ImageCodec, with label, no pix_fmt override."""
    codec = ImageCodec(800, 600, "rgb24", (1, 30), (4, 3))
    codeflash_output = get_buffer_desc(codec, label="img1"); result = codeflash_output # 2.65μs -> 2.21μs (19.9% faster)
    expected = "buffer@img1=video_size=800x600:pix_fmt=rgb24:time_base=1/30:pixel_aspect=4/3"

def test_basic_pix_fmt_override():
    """Basic: Override pix_fmt."""
    codec = VideoCodec(640, 480, "yuv444p", (1001, 30000), (16, 9))
    codeflash_output = get_buffer_desc(codec, pix_fmt="gray"); result = codeflash_output # 2.48μs -> 2.16μs (15.1% faster)
    expected = "buffer=video_size=640x480:pix_fmt=gray:time_base=1001/30000:pixel_aspect=16/9"

def test_basic_pix_fmt_and_label_override():
    """Basic: Override both pix_fmt and label."""
    codec = ImageCodec(1024, 768, "rgba", (1, 60), (1, 1))
    codeflash_output = get_buffer_desc(codec, label="main", pix_fmt="bgra"); result = codeflash_output # 2.43μs -> 2.27μs (6.64% faster)
    expected = "buffer@main=video_size=1024x768:pix_fmt=bgra:time_base=1/60:pixel_aspect=1/1"

# 2. Edge Test Cases

def test_edge_zero_dimensions():
    """Edge: Zero width and height."""
    codec = VideoCodec(0, 0, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.01μs -> 1.85μs (8.25% faster)
    expected = "buffer=video_size=0x0:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_edge_negative_dimensions():
    """Edge: Negative width and height."""
    codec = VideoCodec(-1920, -1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.17μs -> 1.79μs (21.2% faster)
    expected = "buffer=video_size=-1920x-1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_edge_zero_time_base():
    """Edge: Zero time_base values."""
    codec = VideoCodec(1280, 720, "yuv420p", (0, 0), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 1.99μs -> 1.79μs (11.4% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=yuv420p:time_base=0/0:pixel_aspect=1/1"

def test_edge_negative_time_base():
    """Edge: Negative time_base values."""
    codec = VideoCodec(1280, 720, "yuv420p", (-1, -25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.09μs -> 1.88μs (11.1% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=yuv420p:time_base=-1/-25:pixel_aspect=1/1"

def test_edge_zero_aspect_ratio():
    """Edge: Zero aspect ratio values."""
    codec = VideoCodec(1280, 720, "yuv420p", (1, 25), (0, 0))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.02μs -> 1.69μs (19.5% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=0/0"

def test_edge_negative_aspect_ratio():
    """Edge: Negative aspect ratio values."""
    codec = VideoCodec(1280, 720, "yuv420p", (1, 25), (-4, -3))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.10μs -> 1.72μs (22.6% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=-4/-3"

def test_edge_empty_pix_fmt():
    """Edge: Empty string as pix_fmt."""
    codec = VideoCodec(1280, 720, "", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.07μs -> 1.54μs (34.8% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=:time_base=1/25:pixel_aspect=1/1"

def test_edge_empty_pix_fmt_override():
    """Edge: Override pix_fmt with empty string."""
    codec = VideoCodec(1280, 720, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, pix_fmt=""); result = codeflash_output # 2.34μs -> 1.92μs (21.7% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=:time_base=1/25:pixel_aspect=1/1"

def test_edge_label_special_characters():
    """Edge: Label with special characters."""
    codec = VideoCodec(1280, 720, "yuv420p", (1, 25), (1, 1))
    label = "input@#1$%&"
    codeflash_output = get_buffer_desc(codec, label=label); result = codeflash_output # 2.25μs -> 2.05μs (9.75% faster)
    expected = f"buffer@{label}=video_size=1280x720:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_edge_label_empty_string():
    """Edge: Empty string as label."""
    codec = VideoCodec(1280, 720, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, label=""); result = codeflash_output # 2.24μs -> 1.97μs (13.8% faster)
    expected = "buffer@=video_size=1280x720:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_edge_pix_fmt_none_and_empty_codec_pix_fmt():
    """Edge: pix_fmt=None, codec.pix_fmt is empty."""
    codec = VideoCodec(1280, 720, "", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, pix_fmt=None); result = codeflash_output # 2.19μs -> 1.74μs (25.5% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=:time_base=1/25:pixel_aspect=1/1"

# 3. Large Scale Test Cases

def test_large_scale_max_dimensions():
    """Large Scale: Very large width and height."""
    codec = VideoCodec(9999, 8888, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.00μs -> 1.74μs (14.8% faster)
    expected = "buffer=video_size=9999x8888:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_large_scale_many_invocations():
    """Large Scale: Multiple diverse codecs in a loop."""
    # We'll test 100 codecs for performance and consistency
    for i in range(1, 101):
        codec = VideoCodec(
            width=i,
            height=1000-i,
            pix_fmt=f"pix{i}",
            time_base=(i, i+1),
            sample_aspect_ratio=(i+2, i+3)
        )
        label = f"lbl{i}"
        pix_fmt_override = f"override{i}" if i % 2 == 0 else None
        codeflash_output = get_buffer_desc(codec, label=label, pix_fmt=pix_fmt_override); result = codeflash_output # 90.2μs -> 76.6μs (17.6% faster)
        expected_pix_fmt = pix_fmt_override if pix_fmt_override is not None else f"pix{i}"
        expected = (
            f"buffer@{label}=video_size={i}x{1000-i}:"
            f"pix_fmt={expected_pix_fmt}:"
            f"time_base={i}/{i+1}:"
            f"pixel_aspect={i+2}/{i+3}"
        )

def test_large_scale_long_label():
    """Large Scale: Very long label string."""
    long_label = "L" * 500
    codec = VideoCodec(1920, 1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, label=long_label); result = codeflash_output # 2.53μs -> 2.15μs (17.4% faster)
    expected = f"buffer@{long_label}=video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_large_scale_long_pix_fmt():
    """Large Scale: Very long pix_fmt string."""
    long_pix_fmt = "P" * 500
    codec = VideoCodec(1920, 1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, pix_fmt=long_pix_fmt); result = codeflash_output # 2.50μs -> 2.09μs (19.2% faster)
    expected = f"buffer=video_size=1920x1080:pix_fmt={long_pix_fmt}:time_base=1/25:pixel_aspect=1/1"

def test_large_scale_varied_aspect_ratios():
    """Large Scale: Test many varied aspect ratios."""
    for i in range(1, 101):
        codec = VideoCodec(
            width=1920,
            height=1080,
            pix_fmt="yuv420p",
            time_base=(1, 25),
            sample_aspect_ratio=(i, 1000-i)
        )
        codeflash_output = get_buffer_desc(codec); result = codeflash_output # 78.7μs -> 63.0μs (24.9% faster)
        expected = f"buffer=video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect={i}/{1000-i}"
# 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_buffer_desc


# Dummy codec classes to simulate spdl.io.ImageCodec and spdl.io.VideoCodec
class DummyCodec:
    def __init__(
        self,
        width,
        height,
        pix_fmt,
        time_base,
        sample_aspect_ratio
    ):
        self.width = width
        self.height = height
        self.pix_fmt = pix_fmt
        self.time_base = time_base  # tuple (num, den)
        self.sample_aspect_ratio = sample_aspect_ratio  # tuple (num, den)
from spdl.io._preprocessing import get_buffer_desc

# ------------------- UNIT TESTS -------------------

# Basic Test Cases
def test_basic_no_label_no_pix_fmt():
    # Test with all defaults
    codec = DummyCodec(1920, 1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.54μs -> 2.09μs (21.5% faster)
    expected = "buffer=video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_basic_with_label():
    # Test with label provided
    codec = DummyCodec(640, 480, "rgb24", (1, 30), (4, 3))
    codeflash_output = get_buffer_desc(codec, label="input0"); result = codeflash_output # 2.47μs -> 2.26μs (9.16% faster)
    expected = "buffer@input0=video_size=640x480:pix_fmt=rgb24:time_base=1/30:pixel_aspect=4/3"

def test_basic_with_pix_fmt_override():
    # Test with pix_fmt override
    codec = DummyCodec(1280, 720, "yuv422p", (1001, 30000), (16, 9))
    codeflash_output = get_buffer_desc(codec, pix_fmt="rgba"); result = codeflash_output # 2.42μs -> 2.08μs (16.4% faster)
    expected = "buffer=video_size=1280x720:pix_fmt=rgba:time_base=1001/30000:pixel_aspect=16/9"

def test_basic_with_label_and_pix_fmt():
    # Test with both label and pix_fmt override
    codec = DummyCodec(320, 240, "gray", (1, 60), (1, 2))
    codeflash_output = get_buffer_desc(codec, label="test", pix_fmt="yuv444p"); result = codeflash_output # 2.59μs -> 2.17μs (19.5% faster)
    expected = "buffer@test=video_size=320x240:pix_fmt=yuv444p:time_base=1/60:pixel_aspect=1/2"

# Edge Test Cases

def test_edge_zero_dimensions():
    # Test with zero width and/or height
    codec = DummyCodec(0, 0, "yuv420p", (1, 1), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.00μs -> 1.75μs (14.5% faster)
    expected = "buffer=video_size=0x0:pix_fmt=yuv420p:time_base=1/1:pixel_aspect=1/1"

def test_edge_negative_dimensions():
    # Test with negative width/height
    codec = DummyCodec(-1920, -1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.15μs -> 1.76μs (22.0% faster)
    expected = "buffer=video_size=-1920x-1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1"

def test_edge_zero_time_base():
    # Test with zero denominator in time_base
    codec = DummyCodec(640, 480, "yuv420p", (1, 0), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.11μs -> 1.71μs (23.5% faster)
    expected = "buffer=video_size=640x480:pix_fmt=yuv420p:time_base=1/0:pixel_aspect=1/1"

def test_edge_zero_pixel_aspect():
    # Test with zero denominator in sample_aspect_ratio
    codec = DummyCodec(640, 480, "yuv420p", (1, 30), (1, 0))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.02μs -> 1.71μs (18.1% faster)
    expected = "buffer=video_size=640x480:pix_fmt=yuv420p:time_base=1/30:pixel_aspect=1/0"

def test_edge_empty_pix_fmt():
    # Test with empty string pix_fmt
    codec = DummyCodec(640, 480, "", (1, 30), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.00μs -> 1.65μs (21.2% faster)
    expected = "buffer=video_size=640x480:pix_fmt=:time_base=1/30:pixel_aspect=1/1"

def test_edge_label_empty_string():
    # Test with empty string label
    codec = DummyCodec(640, 480, "yuv420p", (1, 30), (1, 1))
    codeflash_output = get_buffer_desc(codec, label=""); result = codeflash_output # 2.44μs -> 2.05μs (18.9% faster)
    expected = "buffer@=video_size=640x480:pix_fmt=yuv420p:time_base=1/30:pixel_aspect=1/1"

def test_edge_pix_fmt_empty_string_override():
    # Test with pix_fmt override as empty string
    codec = DummyCodec(640, 480, "yuv420p", (1, 30), (1, 1))
    codeflash_output = get_buffer_desc(codec, pix_fmt=""); result = codeflash_output # 2.33μs -> 1.92μs (21.1% faster)
    expected = "buffer=video_size=640x480:pix_fmt=:time_base=1/30:pixel_aspect=1/1"

def test_edge_large_numbers():
    # Test with very large numbers
    codec = DummyCodec(999999, 888888, "yuv420p", (123456789, 987654321), (99999, 88888))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.33μs -> 2.00μs (16.7% faster)
    expected = "buffer=video_size=999999x888888:pix_fmt=yuv420p:time_base=123456789/987654321:pixel_aspect=99999/88888"

def test_edge_small_numbers():
    # Test with very small numbers
    codec = DummyCodec(1, 1, "yuv420p", (1, 1), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 1.93μs -> 1.63μs (18.9% faster)
    expected = "buffer=video_size=1x1:pix_fmt=yuv420p:time_base=1/1:pixel_aspect=1/1"

def test_edge_float_values():
    # Test with float values (should coerce to str as-is)
    codec = DummyCodec(1920.5, 1080.5, "yuv420p", (1.5, 25.5), (1.5, 1.5))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 5.30μs -> 5.01μs (5.95% faster)
    expected = "buffer=video_size=1920.5x1080.5:pix_fmt=yuv420p:time_base=1.5/25.5:pixel_aspect=1.5/1.5"

def test_edge_non_string_pix_fmt():
    # Test with pix_fmt as non-string (e.g., int)
    codec = DummyCodec(640, 480, 123, (1, 30), (1, 1))
    codeflash_output = get_buffer_desc(codec); result = codeflash_output # 2.24μs -> 1.82μs (23.0% faster)
    expected = "buffer=video_size=640x480:pix_fmt=123:time_base=1/30:pixel_aspect=1/1"

def test_edge_non_string_pix_fmt_override():
    # Test with pix_fmt override as non-string (e.g., int)
    codec = DummyCodec(640, 480, "yuv420p", (1, 30), (1, 1))
    codeflash_output = get_buffer_desc(codec, pix_fmt=456); result = codeflash_output # 2.35μs -> 2.04μs (15.0% faster)
    expected = "buffer=video_size=640x480:pix_fmt=456:time_base=1/30:pixel_aspect=1/1"

# Large Scale Test Cases

def test_large_scale_many_codecs():
    # Test with a large number of codecs in a loop
    for i in range(1, 1001, 100):  # 1, 101, ..., 901
        codec = DummyCodec(i, i+1, f"pixfmt{i}", (i, i+2), (i+3, i+4))
        codeflash_output = get_buffer_desc(codec, label=f"label{i}", pix_fmt=f"override{i}"); result = codeflash_output # 10.9μs -> 9.40μs (16.0% faster)
        expected = (
            f"buffer@label{i}=video_size={i}x{i+1}:pix_fmt=override{i}:"
            f"time_base={i}/{i+2}:pixel_aspect={i+3}/{i+4}"
        )

def test_large_scale_long_label_and_pix_fmt():
    # Test with very long label and pix_fmt strings
    long_label = "L" * 256
    long_pix_fmt = "P" * 256
    codec = DummyCodec(1920, 1080, "yuv420p", (1, 25), (1, 1))
    codeflash_output = get_buffer_desc(codec, label=long_label, pix_fmt=long_pix_fmt); result = codeflash_output # 2.37μs -> 2.16μs (9.71% faster)
    expected = (
        f"buffer@{long_label}=video_size=1920x1080:pix_fmt={long_pix_fmt}:"
        "time_base=1/25:pixel_aspect=1/1"
    )

def test_large_scale_varied_pix_fmt():
    # Test with many different pix_fmt values
    for i in range(10):
        pix_fmt = f"format_{i}"
        codec = DummyCodec(100+i, 200+i, pix_fmt, (i+1, i+2), (i+3, i+4))
        codeflash_output = get_buffer_desc(codec); result = codeflash_output # 9.40μs -> 7.91μs (18.8% faster)
        expected = (
            f"buffer=video_size={100+i}x{200+i}:pix_fmt={pix_fmt}:"
            f"time_base={i+1}/{i+2}:pixel_aspect={i+3}/{i+4}"
        )

def test_large_scale_all_fields_different():
    # Test with all fields different for each codec
    for i in range(1, 21):
        codec = DummyCodec(i, i*2, f"pf{i}", (i*3, i*4), (i*5, i*6))
        label = f"lbl{i}"
        pix_fmt = f"pfmt{i}"
        codeflash_output = get_buffer_desc(codec, label=label, pix_fmt=pix_fmt); result = codeflash_output # 19.0μs -> 16.5μs (14.9% faster)
        expected = (
            f"buffer@{label}=video_size={i}x{i*2}:pix_fmt={pix_fmt}:"
            f"time_base={i*3}/{i*4}:pixel_aspect={i*5}/{i*6}"
        )

def test_large_scale_maximum_values():
    # Test with maximum reasonable values for width, height, etc.
    codec = DummyCodec(9999, 9999, "maxfmt", (9999, 9999), (9999, 9999))
    codeflash_output = get_buffer_desc(codec, label="maxlabel", pix_fmt="maxpixfmt"); result = codeflash_output # 2.03μs -> 1.81μs (12.0% faster)
    expected = (
        "buffer@maxlabel=video_size=9999x9999:pix_fmt=maxpixfmt:time_base=9999/9999:pixel_aspect=9999/9999"
    )
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from spdl.io._preprocessing import get_buffer_desc
from spdl.io._type_stub import ImageCodec
import pytest

def test_get_buffer_desc():
    with pytest.raises(TypeError, match="'NoneType'\\ object\\ is\\ not\\ subscriptable"):
        get_buffer_desc(ImageCodec(), label='', pix_fmt='')

def test_get_buffer_desc_2():
    with pytest.raises(TypeError, match="'NoneType'\\ object\\ is\\ not\\ subscriptable"):
        get_buffer_desc(ImageCodec(), label=None, pix_fmt='')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_uafn4wd5/tmpcc9_gdab/test_concolic_coverage.py::test_get_buffer_desc	3.32μs	2.88μs	15.3%✅
codeflash_concolic_uafn4wd5/tmpcc9_gdab/test_concolic_coverage.py::test_get_buffer_desc_2	2.46μs	2.15μs	14.3%✅

To edit these changes git checkout codeflash/optimize-get_buffer_desc-mgraipdb and push.