⚡️ Speed up function is_file_content by 18%

[codeflash-ai]

📄 18% (0.18x) speedup for is_file_content in src/anthropic/_files.py

⏱️ Runtime : 2.67 milliseconds → 2.26 milliseconds (best of 135 runs)

📝 Explanation and details

The optimization replaces multiple individual isinstance() calls with a single isinstance() call using a tuple of types. The key changes are:

1. Pre-computed type tuple: _FILE_CONTENT_TYPES = (bytes, tuple, io.IOBase, os.PathLike) is defined once at module level
2. Single isinstance() call: isinstance(obj, _FILE_CONTENT_TYPES) instead of four separate calls connected by or

Why this is faster:

• Python's isinstance() function is optimized to handle tuple arguments efficiently in C code, avoiding the overhead of multiple function calls and boolean operations
• The original code performs up to 4 separate isinstance() calls and 3 or evaluations, while the optimized version makes just 1 function call
• Short-circuiting in the original or chain still requires multiple Python bytecode operations, whereas the tuple approach delegates the type checking to optimized C code

Performance characteristics from tests:

• Best for non-matching types: Shows 15-42% speedup for objects that don't match any of the target types (str, int, list, dict, None), as it avoids multiple failed isinstance checks
• Good for complex types: 13-25% speedup for io.IOBase and os.PathLike objects, which are typically checked last in the original chain
• Mixed results for simple types: bytes and tuple show variable performance (some slower, some faster) likely due to their position in the type checking order, but overall the function is still faster due to reduced overhead

The 17% overall speedup comes from eliminating the Python-level boolean operations and multiple function call overhead in favor of a single optimized C-level type check.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import io
import os

# imports
import pytest  # used for our unit tests
from anthropic._files import is_file_content
# function to test
from typing_extensions import TypeGuard

# unit tests

# ========== BASIC TEST CASES ==========

def test_bytes_type_true():
    # Should return True for bytes objects
    codeflash_output = is_file_content(b"hello world") # 323ns -> 371ns (12.9% slower)

def test_tuple_type_true():
    # Should return True for tuple objects
    codeflash_output = is_file_content((1, 2, 3)) # 496ns -> 475ns (4.42% faster)

def test_io_base_true():
    # Should return True for io.IOBase objects (file-like objects)
    with io.BytesIO(b"abc") as f:
        codeflash_output = is_file_content(f) # 1.15μs -> 965ns (18.8% faster)

def test_os_pathlike_true():
    # Should return True for os.PathLike objects
    class MyPath(os.PathLike):
        def __fspath__(self):
            return "/tmp/file.txt"
    path_obj = MyPath()
    codeflash_output = is_file_content(path_obj) # 28.8μs -> 28.0μs (2.86% faster)

def test_str_false():
    # Should return False for str objects
    codeflash_output = not is_file_content("not a file content") # 1.55μs -> 1.30μs (18.7% faster)

def test_int_false():
    # Should return False for int objects
    codeflash_output = not is_file_content(123) # 1.54μs -> 1.33μs (15.6% faster)

def test_list_false():
    # Should return False for list objects
    codeflash_output = not is_file_content([1, 2, 3]) # 1.45μs -> 1.23μs (18.2% faster)

def test_dict_false():
    # Should return False for dict objects
    codeflash_output = not is_file_content({"a": 1}) # 1.45μs -> 1.22μs (18.6% faster)

def test_none_false():
    # Should return False for None
    codeflash_output = not is_file_content(None) # 1.46μs -> 1.03μs (41.2% faster)

# ========== EDGE TEST CASES ==========

def test_empty_bytes_true():
    # Should return True for empty bytes
    codeflash_output = is_file_content(b"") # 361ns -> 359ns (0.557% faster)

def test_empty_tuple_true():
    # Should return True for empty tuple
    codeflash_output = is_file_content(()) # 497ns -> 466ns (6.65% faster)

def test_empty_io_base_true():
    # Should return True for empty io.BytesIO
    with io.BytesIO() as f:
        codeflash_output = is_file_content(f) # 1.11μs -> 983ns (13.1% faster)

def test_subclass_of_bytes_true():
    # Should return True for subclass of bytes
    class MyBytes(bytes):
        pass
    codeflash_output = is_file_content(MyBytes(b"abc")) # 351ns -> 402ns (12.7% slower)

def test_subclass_of_tuple_true():
    # Should return True for subclass of tuple
    class MyTuple(tuple):
        pass
    codeflash_output = is_file_content(MyTuple((1, 2))) # 596ns -> 594ns (0.337% faster)

def test_subclass_of_io_base_true():
    # Should return True for subclass of io.IOBase
    class MyIO(io.BytesIO):
        pass
    with MyIO(b"abc") as f:
        codeflash_output = is_file_content(f) # 17.8μs -> 18.3μs (2.53% slower)

def test_subclass_of_os_pathlike_true():
    # Should return True for subclass of os.PathLike
    class MyPath(os.PathLike):
        def __fspath__(self):
            return "/tmp/file.txt"
    path_obj = MyPath()
    codeflash_output = is_file_content(path_obj) # 25.8μs -> 24.2μs (6.66% faster)

def test_bytesarray_false():
    # Should return False for bytearray (not bytes)
    codeflash_output = not is_file_content(bytearray(b"abc")) # 1.56μs -> 1.22μs (27.8% faster)

def test_tuple_with_bytes_true():
    # Should return True for tuple even if it contains bytes
    t = (b"abc", b"def")
    codeflash_output = is_file_content(t) # 480ns -> 502ns (4.38% slower)

def test_tuple_with_mixed_types_true():
    # Should return True for tuple with mixed types
    t = (b"abc", 123, "xyz")
    codeflash_output = is_file_content(t) # 426ns -> 455ns (6.37% slower)

def test_custom_object_false():
    # Should return False for custom object not inheriting from valid types
    class Custom:
        pass
    codeflash_output = not is_file_content(Custom()) # 27.0μs -> 27.3μs (1.32% slower)

def test_pathlib_path_true():
    # Should return True for pathlib.Path (os.PathLike)
    import pathlib
    p = pathlib.Path("/tmp/file.txt")
    codeflash_output = is_file_content(p) # 1.59μs -> 1.35μs (18.2% faster)

def test_pathlike_with_non_str_fspath_true():
    # Should return True for os.PathLike subclass with non-str __fspath__ return
    class MyPath(os.PathLike):
        def __fspath__(self):
            return 123  # Not a string, but still PathLike
    path_obj = MyPath()
    codeflash_output = is_file_content(path_obj) # 24.7μs -> 23.6μs (4.50% faster)

# ========== LARGE SCALE TEST CASES ==========

def test_large_bytes_true():
    # Should return True for large bytes object (~1MB)
    large_bytes = b"a" * (1024 * 1024)
    codeflash_output = is_file_content(large_bytes) # 425ns -> 400ns (6.25% faster)

def test_large_tuple_true():
    # Should return True for large tuple (1000 elements)
    large_tuple = tuple(range(1000))
    codeflash_output = is_file_content(large_tuple) # 531ns -> 516ns (2.91% faster)

def test_large_file_like_true(tmp_path):
    # Should return True for large file-like object
    file_path = tmp_path / "bigfile.bin"
    data = b"x" * (1024 * 1024)
    file_path.write_bytes(data)
    with open(file_path, "rb") as f:
        codeflash_output = is_file_content(f) # 2.22μs -> 1.77μs (25.7% faster)

def test_many_pathlike_objects_true():
    # Should return True for many os.PathLike objects in a list
    import pathlib
    paths = [pathlib.Path(f"/tmp/file_{i}.txt") for i in range(1000)]
    for p in paths:
        codeflash_output = is_file_content(p) # 477μs -> 386μs (23.3% faster)

def test_many_bytes_objects_true():
    # Should return True for many bytes objects in a list
    bytes_list = [b"x" * 10 for _ in range(1000)]
    for b in bytes_list:
        codeflash_output = is_file_content(b) # 127μs -> 122μs (4.30% faster)

def test_many_tuple_objects_true():
    # Should return True for many tuple objects in a list
    tuples = [tuple(range(10)) for _ in range(1000)]
    for t in tuples:
        codeflash_output = is_file_content(t) # 151μs -> 138μs (9.17% faster)

def test_many_io_base_objects_true():
    # Should return True for many io.BytesIO objects in a list
    files = [io.BytesIO(b"abc") for _ in range(1000)]
    for f in files:
        codeflash_output = is_file_content(f) # 318μs -> 267μs (18.9% faster)

def test_large_mixed_types_false():
    # Should return False for large list of non-matching types
    non_file_contents = [str(i) for i in range(1000)]
    for obj in non_file_contents:
        codeflash_output = not is_file_content(obj) # 480μs -> 388μs (23.8% faster)

# ========== DETERMINISM TEST CASES ==========

def test_determinism_bytes():
    # Should always return True for bytes
    for _ in range(10):
        codeflash_output = is_file_content(b"abc") # 1.57μs -> 1.58μs (0.570% slower)

def test_determinism_int():
    # Should always return False for int
    for _ in range(10):
        codeflash_output = not is_file_content(42) # 6.42μs -> 5.12μs (25.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 io
import os

# imports
import pytest  # used for our unit tests
from anthropic._files import is_file_content
# function to test
from typing_extensions import TypeGuard

# unit tests

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

def test_bytes_true():
    # Basic: bytes input should return True
    codeflash_output = is_file_content(b"hello world") # 283ns -> 344ns (17.7% slower)

def test_tuple_true():
    # Basic: tuple input should return True
    codeflash_output = is_file_content((1, 2, 3)) # 464ns -> 430ns (7.91% faster)

def test_io_base_true():
    # Basic: io.IOBase (BytesIO) input should return True
    with io.BytesIO(b"abc") as f:
        codeflash_output = is_file_content(f) # 1.18μs -> 1.04μs (13.1% faster)

def test_os_pathlike_true():
    # Basic: os.PathLike input should return True
    class DummyPath(os.PathLike):
        def __fspath__(self):
            return "/tmp/file"
    dummy = DummyPath()
    codeflash_output = is_file_content(dummy) # 29.2μs -> 28.4μs (2.80% faster)

def test_str_false():
    # Basic: str input should return False
    codeflash_output = not is_file_content("hello.txt") # 1.55μs -> 1.28μs (21.4% faster)

def test_int_false():
    # Basic: int input should return False
    codeflash_output = not is_file_content(42) # 1.57μs -> 1.19μs (32.6% faster)

def test_list_false():
    # Basic: list input should return False
    codeflash_output = not is_file_content([1, 2, 3]) # 1.48μs -> 1.17μs (25.9% faster)

def test_dict_false():
    # Basic: dict input should return False
    codeflash_output = not is_file_content({"a": 1}) # 1.49μs -> 1.17μs (26.5% faster)

def test_none_false():
    # Basic: None input should return False
    codeflash_output = not is_file_content(None) # 1.42μs -> 1.15μs (22.9% faster)

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

def test_empty_bytes_true():
    # Edge: empty bytes should return True
    codeflash_output = is_file_content(b"") # 314ns -> 373ns (15.8% slower)

def test_empty_tuple_true():
    # Edge: empty tuple should return True
    codeflash_output = is_file_content(()) # 460ns -> 477ns (3.56% slower)

def test_empty_bytesio_true():
    # Edge: empty BytesIO should return True
    with io.BytesIO() as f:
        codeflash_output = is_file_content(f) # 1.10μs -> 945ns (16.7% faster)

def test_custom_pathlike_subclass_true():
    # Edge: subclass of os.PathLike should return True
    class MyPath(os.PathLike):
        def __fspath__(self):
            return "/tmp/another"
    codeflash_output = is_file_content(MyPath()) # 27.3μs -> 26.8μs (1.68% faster)

def test_tuple_of_bytes_true():
    # Edge: tuple containing bytes is still a tuple, should return True
    codeflash_output = is_file_content((b"abc", b"def")) # 449ns -> 479ns (6.26% slower)

def test_tuple_of_non_bytes_true():
    # Edge: tuple containing non-bytes is still a tuple, should return True
    codeflash_output = is_file_content((1, "a", None)) # 446ns -> 443ns (0.677% faster)

def test_tuple_empty_true():
    # Edge: empty tuple should return True
    codeflash_output = is_file_content(()) # 421ns -> 436ns (3.44% slower)

def test_custom_io_base_subclass_true():
    # Edge: subclass of io.IOBase should return True
    class MyIO(io.BytesIO):
        pass
    with MyIO(b"data") as f:
        codeflash_output = is_file_content(f) # 17.1μs -> 16.9μs (1.02% faster)

def test_pathlib_path_true():
    # Edge: pathlib.Path is a PathLike, should return True
    import pathlib
    p = pathlib.Path("/tmp/file")
    codeflash_output = is_file_content(p) # 1.73μs -> 1.30μs (32.4% faster)

def test_bytes_subclass_true():
    # Edge: subclass of bytes should return True
    class MyBytes(bytes):
        pass
    codeflash_output = is_file_content(MyBytes(b"abc")) # 329ns -> 390ns (15.6% slower)

def test_tuple_subclass_true():
    # Edge: subclass of tuple should return True
    class MyTuple(tuple):
        pass
    codeflash_output = is_file_content(MyTuple((1, 2, 3))) # 635ns -> 610ns (4.10% faster)

def test_io_stringio_false():
    # Edge: io.StringIO is not a subclass of io.IOBase, should return False
    with io.StringIO("abc") as f:
        codeflash_output = not is_file_content(f) # 1.17μs -> 1.05μs (11.6% faster)

def test_pathlike_nonclass_false():
    # Edge: object with __fspath__ but not subclassing PathLike should return False
    class FakePath:
        def __fspath__(self):
            return "/tmp/fake"
    codeflash_output = not is_file_content(FakePath()) # 27.7μs -> 26.7μs (3.53% faster)



def test_tuple_with_file_false():
    # Edge: tuple containing file object is still a tuple, should return True
    with io.BytesIO(b"abc") as f:
        codeflash_output = is_file_content((f,)) # 443ns -> 445ns (0.449% slower)

def test_tuple_subclass_with_bytes_true():
    # Edge: tuple subclass containing bytes should return True
    class MyTuple(tuple):
        pass
    codeflash_output = is_file_content(MyTuple((b"abc",))) # 613ns -> 558ns (9.86% faster)

def test_custom_object_false():
    # Edge: completely custom object should return False
    class Custom:
        pass
    codeflash_output = not is_file_content(Custom()) # 26.6μs -> 26.4μs (0.822% faster)

def test_bool_false():
    # Edge: bool is not valid, should return False
    codeflash_output = not is_file_content(True) # 1.55μs -> 1.39μs (11.7% faster)
    codeflash_output = not is_file_content(False) # 670ns -> 540ns (24.1% faster)

def test_float_false():
    # Edge: float is not valid, should return False
    codeflash_output = not is_file_content(3.1415) # 1.41μs -> 1.16μs (21.8% faster)

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

def test_large_bytes_true():
    # Large: large bytes object should return True
    big_bytes = b"a" * 1000
    codeflash_output = is_file_content(big_bytes) # 343ns -> 347ns (1.15% slower)

def test_large_tuple_true():
    # Large: large tuple should return True
    big_tuple = tuple(range(1000))
    codeflash_output = is_file_content(big_tuple) # 475ns -> 484ns (1.86% slower)

def test_large_tuple_of_bytes_true():
    # Large: tuple of many bytes objects should return True
    big_tuple_bytes = tuple(b"x" * i for i in range(1, 1001))
    codeflash_output = is_file_content(big_tuple_bytes) # 562ns -> 521ns (7.87% faster)

def test_large_list_false():
    # Large: large list should return False
    big_list = [i for i in range(1000)]
    codeflash_output = not is_file_content(big_list) # 1.85μs -> 1.48μs (25.4% faster)

def test_large_dict_false():
    # Large: large dict should return False
    big_dict = {str(i): i for i in range(1000)}
    codeflash_output = not is_file_content(big_dict) # 1.61μs -> 1.32μs (22.0% faster)

def test_many_files_true():
    # Large: many file objects should all return True
    files = [io.BytesIO(b"x" * i) for i in range(1, 1001)]
    for f in files:
        codeflash_output = is_file_content(f) # 324μs -> 272μs (19.3% faster)

def test_many_pathlike_true():
    # Large: many PathLike objects should all return True
    import pathlib
    paths = [pathlib.Path(f"/tmp/{i}") for i in range(1000)]
    for p in paths:
        codeflash_output = is_file_content(p) # 481μs -> 391μs (23.1% faster)

def test_large_tuple_subclass_true():
    # Large: subclass of tuple with many elements should return True
    class MyTuple(tuple):
        pass
    big_tuple = MyTuple(range(1000))
    codeflash_output = is_file_content(big_tuple) # 698ns -> 616ns (13.3% faster)

def test_large_bytes_subclass_true():
    # Large: subclass of bytes with large content should return True
    class MyBytes(bytes):
        pass
    big_bytes = MyBytes(b"x" * 1000)
    codeflash_output = is_file_content(big_bytes) # 330ns -> 367ns (10.1% slower)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from anthropic._files import is_file_content

def test_is_file_content():
    is_file_content('')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_6zuacb2h/tmpwomw08wl/test_concolic_coverage.py::test_is_file_content	1.96μs	1.54μs	27.0%✅

To edit these changes git checkout codeflash/optimize-is_file_content-mhe23dg7 and push.