⚡️ Speed up function with_content_type by 251%

[codeflash-ai]

📄 251% (2.51x) speedup for with_content_type in skyvern/client/core/file.py

⏱️ Runtime : 1.10 milliseconds → 314 microseconds (best of 250 runs)

📝 Explanation and details

The optimized code achieves a 251% speedup by eliminating expensive cast() operations and improving control flow efficiency.

Key Optimizations:

1. Eliminated expensive cast() calls: The original code used cast() on every tuple unpacking operation, which consumed 56% of total runtime (lines showing 25.7% and 30.5% in profiler). The optimized version removes these entirely, relying on Python's native tuple unpacking which is much faster.

2. Reordered branches for common case: Moved the non-tuple check first with if not isinstance(file, tuple), optimizing for the most common usage pattern where files are passed as raw content rather than tuples.

3. Cached len(file) computation: Stored the length in len_file variable to avoid repeated len() calls across the elif chain.

Performance Impact by Test Case:

• Non-tuple cases (bytes, str, IO): 3-18% faster due to early branch optimization
• 2-element tuples: ~300-384% faster from eliminating cast operations
• 3-element tuples: ~260-315% faster, with largest gains on content type resolution
• 4-element tuples: ~299-483% faster, especially beneficial for header-heavy operations
• Large-scale tests: Up to 424% faster when processing many files with tuples

The optimization is particularly effective for API clients handling file uploads, where tuple-based file specifications with headers and content types are common. The elimination of cast() overhead provides consistent performance gains across all tuple-based operations while maintaining identical functionality and type safety.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import io
# function to test
# (copied from the user's provided code)
from typing import IO, Mapping, Optional, Tuple, Union, cast

# imports
import pytest
from skyvern.client.core.file import with_content_type

FileContent = Union[IO[bytes], bytes, str]
File = Union[
    # file (or bytes)
    FileContent,
    # (filename, file (or bytes))
    Tuple[Optional[str], FileContent],
    # (filename, file (or bytes), content_type)
    Tuple[Optional[str], FileContent, Optional[str]],
    # (filename, file (or bytes), content_type, headers)
    Tuple[
        Optional[str],
        FileContent,
        Optional[str],
        Mapping[str, str],
    ],
]
from skyvern.client.core.file import with_content_type

# unit tests

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

def test_bytes_content_basic():
    # File is just bytes, should wrap with (None, file, default_content_type)
    data = b"hello"
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 616ns -> 609ns (1.15% faster)

def test_str_content_basic():
    # File is just a string, should wrap with (None, file, default_content_type)
    data = "hello"
    codeflash_output = with_content_type(file=data, default_content_type="text/plain"); result = codeflash_output # 709ns -> 667ns (6.30% faster)

def test_io_content_basic():
    # File is an IO[bytes], should wrap with (None, file, default_content_type)
    data = io.BytesIO(b"abc")
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 689ns -> 670ns (2.84% faster)

def test_tuple_filename_and_bytes():
    # File is (filename, bytes), should return (filename, bytes, default_content_type)
    tup = ("myfile.txt", b"abc")
    codeflash_output = with_content_type(file=tup, default_content_type="text/plain"); result = codeflash_output # 3.47μs -> 717ns (384% faster)

def test_tuple_filename_and_str():
    # File is (filename, str), should return (filename, str, default_content_type)
    tup = ("myfile.txt", "abc")
    codeflash_output = with_content_type(file=tup, default_content_type="text/plain"); result = codeflash_output # 2.76μs -> 691ns (300% faster)

def test_tuple_filename_and_io():
    # File is (filename, IO[bytes]), should return (filename, IO[bytes], default_content_type)
    stream = io.BytesIO(b"abc")
    tup = ("myfile.txt", stream)
    codeflash_output = with_content_type(file=tup, default_content_type="application/pdf"); result = codeflash_output # 2.68μs -> 689ns (289% faster)

def test_tuple_filename_content_and_content_type():
    # File is (filename, content, content_type), should preserve content_type
    tup = ("myfile.txt", b"abc", "image/png")
    codeflash_output = with_content_type(file=tup, default_content_type="application/octet-stream"); result = codeflash_output # 3.20μs -> 780ns (311% faster)

def test_tuple_filename_content_and_none_content_type():
    # File is (filename, content, None), should use default_content_type
    tup = ("myfile.txt", b"abc", None)
    codeflash_output = with_content_type(file=tup, default_content_type="image/jpeg"); result = codeflash_output # 3.08μs -> 821ns (276% faster)

def test_tuple_filename_content_and_empty_content_type():
    # File is (filename, content, ""), should use default_content_type
    tup = ("myfile.txt", b"abc", "")
    codeflash_output = with_content_type(file=tup, default_content_type="image/jpeg"); result = codeflash_output # 2.97μs -> 773ns (284% faster)

def test_tuple_filename_content_content_type_and_headers():
    # File is (filename, content, content_type, headers), should preserve content_type and headers
    headers = {"X-Test": "1"}
    tup = ("myfile.txt", b"abc", "application/pdf", headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/octet-stream"); result = codeflash_output # 3.96μs -> 899ns (341% faster)

def test_tuple_filename_content_none_content_type_and_headers():
    # File is (filename, content, None, headers), should use default_content_type
    headers = {"X-Test": "1"}
    tup = ("myfile.txt", b"abc", None, headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/pdf"); result = codeflash_output # 3.52μs -> 850ns (314% faster)

def test_tuple_filename_content_empty_content_type_and_headers():
    # File is (filename, content, "", headers), should use default_content_type
    headers = {"X-Test": "1"}
    tup = ("myfile.txt", b"abc", "", headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/pdf"); result = codeflash_output # 3.51μs -> 880ns (299% faster)

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

def test_tuple_with_none_filename():
    # (None, content) should be accepted and handled
    tup = (None, b"abc")
    codeflash_output = with_content_type(file=tup, default_content_type="text/plain"); result = codeflash_output # 2.61μs -> 690ns (278% faster)

def test_tuple_with_none_filename_and_content_type():
    # (None, content, content_type)
    tup = (None, b"abc", "image/jpeg")
    codeflash_output = with_content_type(file=tup, default_content_type="application/octet-stream"); result = codeflash_output # 2.98μs -> 765ns (290% faster)

def test_tuple_with_none_filename_content_type_and_headers():
    # (None, content, None, headers)
    headers = {"A": "B"}
    tup = (None, b"abc", None, headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/json"); result = codeflash_output # 3.62μs -> 876ns (313% faster)

def test_tuple_with_empty_filename():
    # ("", content) should be accepted and handled
    tup = ("", b"abc")
    codeflash_output = with_content_type(file=tup, default_content_type="application/json"); result = codeflash_output # 2.56μs -> 678ns (277% faster)

def test_tuple_with_empty_filename_content_type_and_headers():
    # ("", content, "", headers)
    headers = {"A": "B"}
    tup = ("", b"abc", "", headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/json"); result = codeflash_output # 3.67μs -> 907ns (305% faster)

def test_tuple_with_unexpected_length():
    # Tuple of length 1 should raise ValueError
    with pytest.raises(ValueError):
        with_content_type(file=(b"abc",), default_content_type="text/plain") # 1.45μs -> 1.34μs (8.52% faster)
    # Tuple of length 5 should raise ValueError
    with pytest.raises(ValueError):
        with_content_type(file=("a", b"b", "c", {}, "extra"), default_content_type="text/plain") # 851ns -> 808ns (5.32% faster)

def test_empty_bytes_content():
    # File is empty bytes
    data = b""
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 670ns -> 581ns (15.3% faster)

def test_empty_str_content():
    # File is empty string
    data = ""
    codeflash_output = with_content_type(file=data, default_content_type="text/plain"); result = codeflash_output # 634ns -> 544ns (16.5% faster)

def test_empty_io_content():
    # File is empty IO[bytes]
    data = io.BytesIO(b"")
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 674ns -> 614ns (9.77% faster)

def test_content_type_is_none_and_default_is_empty():
    # If content_type is None and default_content_type is "", should use ""
    tup = ("myfile.txt", b"abc", None)
    codeflash_output = with_content_type(file=tup, default_content_type=""); result = codeflash_output # 3.75μs -> 903ns (315% faster)

def test_content_type_is_empty_and_default_is_none():
    # If content_type is "" and default_content_type is None, should use None
    tup = ("myfile.txt", b"abc", "")
    codeflash_output = with_content_type(file=tup, default_content_type=None); result = codeflash_output # 3.16μs -> 862ns (266% faster)

def test_content_type_is_none_and_default_is_none():
    # If both content_type and default_content_type are None, should use None
    tup = ("myfile.txt", b"abc", None)
    codeflash_output = with_content_type(file=tup, default_content_type=None); result = codeflash_output # 3.05μs -> 840ns (263% faster)

def test_content_type_is_none_and_default_is_falsy():
    # If both content_type and default_content_type are falsy but not None
    tup = ("myfile.txt", b"abc", None)
    codeflash_output = with_content_type(file=tup, default_content_type=""); result = codeflash_output # 2.98μs -> 785ns (280% faster)

def test_content_type_is_empty_and_default_is_falsy():
    # If both content_type and default_content_type are empty string
    tup = ("myfile.txt", b"abc", "")
    codeflash_output = with_content_type(file=tup, default_content_type=""); result = codeflash_output # 2.90μs -> 750ns (287% faster)

def test_headers_are_empty_dict():
    # Headers can be an empty dict
    tup = ("myfile.txt", b"abc", None, {})
    codeflash_output = with_content_type(file=tup, default_content_type="application/pdf"); result = codeflash_output # 3.89μs -> 847ns (359% faster)

def test_headers_are_large_dict():
    # Headers can be a large dict
    headers = {f"X-{i}": str(i) for i in range(100)}
    tup = ("myfile.txt", b"abc", None, headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/json"); result = codeflash_output # 3.69μs -> 860ns (329% faster)

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

def test_large_bytes_content():
    # File is a large bytes object
    data = b"x" * 1000
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 651ns -> 607ns (7.25% faster)

def test_large_str_content():
    # File is a large string
    data = "y" * 1000
    codeflash_output = with_content_type(file=data, default_content_type="text/plain"); result = codeflash_output # 688ns -> 583ns (18.0% faster)

def test_many_files_with_various_types():
    # Test many files with different types in a loop
    for i in range(100):
        # bytes
        data = bytes([i % 256]) * (i + 1)
        codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 18.1μs -> 17.2μs (5.48% faster)
        # str
        s = chr(65 + (i % 26)) * (i + 1)
        codeflash_output = with_content_type(file=s, default_content_type="text/plain"); result = codeflash_output # 17.0μs -> 16.5μs (3.36% faster)
        # IO[bytes]
        stream = io.BytesIO(data)
        codeflash_output = with_content_type(file=stream, default_content_type="application/octet-stream"); result = codeflash_output
        # (filename, content)
        tup = (f"file{i}.txt", data) # 18.8μs -> 18.1μs (4.13% faster)
        codeflash_output = with_content_type(file=tup, default_content_type="application/pdf"); result = codeflash_output
        # (filename, content, content_type)
        tup3 = (f"file{i}.txt", data, "image/png")
        codeflash_output = with_content_type(file=tup3, default_content_type="application/pdf"); result = codeflash_output # 85.0μs -> 20.4μs (317% faster)
        # (filename, content, None, headers)
        headers = {"A": str(i)}
        tup4 = (f"file{i}.txt", data, None, headers)
        codeflash_output = with_content_type(file=tup4, default_content_type="application/json"); result = codeflash_output # 103μs -> 19.7μs (424% faster)

def test_large_headers_dict():
    # Test with a large headers dict (max 1000 keys)
    headers = {f"Header-{i}": f"Value-{i}" for i in range(1000)}
    tup = ("bigfile.txt", b"abc", None, headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/json"); result = codeflash_output # 4.01μs -> 688ns (483% faster)

def test_large_tuple_filename_and_content():
    # Test with a large content in tuple (filename, content)
    data = b"z" * 1000
    tup = ("largefile.bin", data)
    codeflash_output = with_content_type(file=tup, default_content_type="application/octet-stream"); result = codeflash_output # 2.43μs -> 558ns (335% faster)

def test_large_tuple_filename_content_content_type_and_headers():
    # Test with a large content and large headers in (filename, content, content_type, headers)
    data = b"w" * 1000
    headers = {f"X-{i}": str(i) for i in range(500)}
    tup = ("bigfile.bin", data, "application/x-custom", headers)
    codeflash_output = with_content_type(file=tup, default_content_type="application/octet-stream"); result = codeflash_output # 3.46μs -> 844ns (309% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import io
# function to test
# (copied exactly as provided)
# --- Begin function under test ---
from typing import IO, Mapping, Optional, Tuple, Union, cast

# imports
import pytest
from skyvern.client.core.file import with_content_type

FileContent = Union[IO[bytes], bytes, str]
File = Union[
    # file (or bytes)
    FileContent,
    # (filename, file (or bytes))
    Tuple[Optional[str], FileContent],
    # (filename, file (or bytes), content_type)
    Tuple[Optional[str], FileContent, Optional[str]],
    # (filename, file (or bytes), content_type, headers)
    Tuple[
        Optional[str],
        FileContent,
        Optional[str],
        Mapping[str, str],
    ],
]
from skyvern.client.core.file import \
    with_content_type  # --- End function under test ---

# unit tests

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

def test_bytes_content_no_filename():
    # file as bytes, no filename
    codeflash_output = with_content_type(file=b"abc", default_content_type="application/octet-stream"); result = codeflash_output # 611ns -> 543ns (12.5% faster)

def test_str_content_no_filename():
    # file as str, no filename
    codeflash_output = with_content_type(file="hello", default_content_type="text/plain"); result = codeflash_output # 660ns -> 604ns (9.27% faster)

def test_fileobj_content_no_filename():
    # file as file-like object, no filename
    f = io.BytesIO(b"data")
    codeflash_output = with_content_type(file=f, default_content_type="application/pdf"); result = codeflash_output # 675ns -> 628ns (7.48% faster)

def test_tuple_filename_and_content():
    # file as (filename, content)
    codeflash_output = with_content_type(file=("file.txt", b"abc"), default_content_type="text/plain"); result = codeflash_output # 3.09μs -> 684ns (352% faster)

def test_tuple_filename_none_and_content():
    # file as (None, content)
    codeflash_output = with_content_type(file=(None, b"abc"), default_content_type="application/json"); result = codeflash_output # 2.65μs -> 655ns (305% faster)

def test_tuple_filename_content_content_type():
    # file as (filename, content, content_type)
    codeflash_output = with_content_type(file=("file.txt", b"abc", "image/png"), default_content_type="application/octet-stream"); result = codeflash_output # 3.24μs -> 779ns (316% faster)

def test_tuple_filename_content_none_content_type():
    # file as (filename, content, None) for content_type, should fallback to default
    codeflash_output = with_content_type(file=("file.txt", b"abc", None), default_content_type="image/jpeg"); result = codeflash_output # 2.98μs -> 830ns (260% faster)

def test_tuple_filename_content_content_type_headers():
    # file as (filename, content, content_type, headers)
    headers = {"X-Test": "1"}
    codeflash_output = with_content_type(file=("file.txt", b"abc", "image/gif", headers), default_content_type="application/pdf"); result = codeflash_output # 3.84μs -> 920ns (317% faster)

def test_tuple_filename_content_none_content_type_headers():
    # file as (filename, content, None, headers), should fallback to default content type
    headers = {"X-Test": "2"}
    codeflash_output = with_content_type(file=("file.txt", b"abc", None, headers), default_content_type="image/svg+xml"); result = codeflash_output # 3.57μs -> 805ns (343% faster)

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

def test_empty_bytes_content():
    # file as empty bytes
    codeflash_output = with_content_type(file=b"", default_content_type="application/octet-stream"); result = codeflash_output # 653ns -> 604ns (8.11% faster)

def test_empty_str_content():
    # file as empty string
    codeflash_output = with_content_type(file="", default_content_type="text/plain"); result = codeflash_output # 624ns -> 564ns (10.6% faster)

def test_empty_fileobj_content():
    # file as empty file-like object
    f = io.BytesIO(b"")
    codeflash_output = with_content_type(file=f, default_content_type="application/pdf"); result = codeflash_output # 706ns -> 600ns (17.7% faster)

def test_tuple_filename_empty_bytes():
    # file as (filename, empty bytes)
    codeflash_output = with_content_type(file=("empty.txt", b""), default_content_type="text/plain"); result = codeflash_output # 3.04μs -> 688ns (342% faster)

def test_tuple_filename_content_type_empty_string():
    # file as (filename, content, ""), should fallback to default content type
    codeflash_output = with_content_type(file=("file.txt", b"abc", ""), default_content_type="application/xml"); result = codeflash_output # 3.15μs -> 832ns (279% faster)

def test_tuple_filename_content_type_empty_string_headers():
    # file as (filename, content, "", headers), should fallback to default content type
    headers = {"A": "B"}
    codeflash_output = with_content_type(file=("file.txt", b"abc", "", headers), default_content_type="text/markdown"); result = codeflash_output # 3.89μs -> 870ns (347% faster)

def test_tuple_filename_none_content_type_headers():
    # file as (None, content, None, headers), should fallback to default content type
    headers = {"Header": "Val"}
    codeflash_output = with_content_type(file=(None, b"abc", None, headers), default_content_type="application/zip"); result = codeflash_output # 3.61μs -> 826ns (337% faster)

def test_tuple_filename_content_type_none_headers_empty():
    # file as (filename, content, None, empty headers dict)
    codeflash_output = with_content_type(file=("file.txt", b"abc", None, {}), default_content_type="application/x-empty"); result = codeflash_output # 3.54μs -> 842ns (321% faster)

def test_tuple_filename_content_type_none_headers_large():
    # file as (filename, content, None, large headers dict)
    headers = {f"Header-{i}": str(i) for i in range(10)}
    codeflash_output = with_content_type(file=("file.txt", b"abc", None, headers), default_content_type="application/x-large"); result = codeflash_output # 3.44μs -> 798ns (332% faster)

def test_tuple_with_unexpected_length_1():
    # file as tuple of length 1, should raise ValueError
    with pytest.raises(ValueError):
        with_content_type(file=("file.txt",), default_content_type="application/octet-stream") # 1.47μs -> 1.47μs (0.340% slower)

def test_tuple_with_unexpected_length_5():
    # file as tuple of length 5, should raise ValueError
    with pytest.raises(ValueError):
        with_content_type(file=("file.txt", b"abc", "image/png", {}, "extra"), default_content_type="application/octet-stream") # 1.34μs -> 1.25μs (7.78% faster)

def test_tuple_with_unexpected_length_0():
    # file as empty tuple, should raise ValueError
    with pytest.raises(ValueError):
        with_content_type(file=(), default_content_type="application/octet-stream") # 1.27μs -> 1.22μs (4.36% faster)

def test_none_as_file():
    # file as None, should treat as content
    codeflash_output = with_content_type(file=None, default_content_type="application/x-null"); result = codeflash_output # 641ns -> 582ns (10.1% faster)

def test_content_type_is_none_and_default_is_empty():
    # file as (filename, content, None), default_content_type is empty string
    codeflash_output = with_content_type(file=("file.txt", b"abc", None), default_content_type=""); result = codeflash_output # 3.75μs -> 871ns (331% faster)

def test_content_type_is_empty_and_default_is_none():
    # file as (filename, content, ""), default_content_type is None
    codeflash_output = with_content_type(file=("file.txt", b"abc", ""), default_content_type=None); result = codeflash_output # 3.15μs -> 811ns (288% faster)

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

def test_large_bytes_content():
    # file as large bytes object (~1KB)
    data = b"a" * 1000
    codeflash_output = with_content_type(file=data, default_content_type="application/octet-stream"); result = codeflash_output # 635ns -> 615ns (3.25% faster)

def test_large_str_content():
    # file as large string (~1KB)
    data = "b" * 1000
    codeflash_output = with_content_type(file=data, default_content_type="text/plain"); result = codeflash_output # 660ns -> 589ns (12.1% faster)

def test_large_fileobj_content():
    # file as large file-like object (~1KB)
    f = io.BytesIO(b"c" * 1000)
    codeflash_output = with_content_type(file=f, default_content_type="application/pdf"); result = codeflash_output # 680ns -> 633ns (7.42% faster)

def test_many_headers_in_tuple():
    # file as (filename, content, content_type, headers) with many headers
    headers = {f"Header-{i}": f"Value-{i}" for i in range(100)}
    codeflash_output = with_content_type(file=("file.txt", b"abc", "application/x-many", headers), default_content_type="application/x-default"); result = codeflash_output # 4.36μs -> 934ns (366% faster)

def test_many_distinct_files():
    # Run with many different files as bytes, str, and file-like objects
    for i in range(100):
        # bytes
        data = bytes([i % 256]) * 10
        codeflash_output = with_content_type(file=data, default_content_type="application/x-bin") # 16.7μs -> 16.1μs (3.73% faster)
        # str
        s = chr(65 + (i % 26)) * 10
        codeflash_output = with_content_type(file=s, default_content_type="application/x-str")
        # file-like
        f = io.BytesIO(b"x" * (i + 1)) # 16.2μs -> 15.6μs (3.98% faster)
        codeflash_output = with_content_type(file=f, default_content_type="application/x-io")

def test_many_distinct_tuples():
    # Run with many different tuple forms
    for i in range(100):
        filename = f"file_{i}.txt"
        content = bytes([i % 256]) * 5
        content_type = f"application/type-{i}"
        headers = {"X-Header": str(i)}
        # (filename, content)
        codeflash_output = with_content_type(file=(filename, content), default_content_type="application/x-def") # 80.4μs -> 18.5μs (335% faster)
        # (filename, content, content_type)
        codeflash_output = with_content_type(file=(filename, content, content_type), default_content_type="application/x-def")
        # (filename, content, None)
        codeflash_output = with_content_type(file=(filename, content, None), default_content_type="application/x-def") # 102μs -> 20.2μs (408% faster)
        # (filename, content, content_type, headers)
        codeflash_output = with_content_type(file=(filename, content, content_type, headers), default_content_type="application/x-def")
        # (filename, content, None, headers)
        codeflash_output = with_content_type(file=(filename, content, None, headers), default_content_type="application/x-def") # 99.8μs -> 19.6μs (410% faster)

def test_large_headers_dict():
    # file as (filename, content, content_type, headers) with large headers dict (1000 entries)
    headers = {f"Header-{i}": f"Value-{i}" for i in range(1000)}
    codeflash_output = with_content_type(file=("bigfile.txt", b"abc", "application/x-big", headers), default_content_type="application/x-def"); result = codeflash_output # 3.95μs -> 703ns (462% 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-with_content_type-mirly2hb and push.