⚡️ Speed up function file_requires_unicode by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for file_requires_unicode in lib/matplotlib/cbook.py

⏱️ Runtime : 1.58 milliseconds → 1.44 milliseconds (best of 78 runs)

📝 Explanation and details

The optimized code adds a fast-path check using hasattr(x, "encoding") before falling back to the original try/except mechanism. This optimization leverages the fact that most text-mode file objects (like io.StringIO and text files) have an encoding attribute, while binary file objects (like io.BytesIO and binary files) typically don't.

Key optimization: The hasattr(x, "encoding") check provides a lightweight way to identify text-mode files without triggering exception handling. When this check succeeds, the function immediately returns True, avoiding the more expensive x.write(b'') call and exception handling.

Performance impact: The 9% overall speedup comes from dramatically improving performance for text-mode files while only slightly degrading performance for binary files:

• Text files see major gains (100-200% faster): StringIO objects and text-mode files benefit significantly because hasattr() is much faster than calling write() and catching a TypeError. The line profiler shows fewer calls to the expensive x.write(b'') operation (4,326 vs 5,630 hits).

• Binary files see minor slowdown (10-25% slower): BytesIO objects and binary files pay a small penalty for the additional hasattr() check, but this cost is minimal compared to the gains on text files.

Why this works: The optimization exploits the common pattern that file-like objects requiring Unicode (text mode) typically expose an encoding attribute, while those accepting bytes (binary mode) generally don't. This heuristic correctly identifies most standard file objects without expensive trial-and-error.

Use case suitability: This optimization is most beneficial for workloads that frequently check text-mode files or mixed file types, as evidenced by the large speedups in StringIO test cases and the positive overall performance gain despite the binary file penalty.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import io

# imports
import pytest
from matplotlib.cbook import file_requires_unicode

# unit tests

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


def test_bytesio_does_not_require_unicode():
    # io.BytesIO accepts bytes, so should return False
    bio = io.BytesIO()
    codeflash_output = file_requires_unicode(bio)  # 540ns -> 711ns (24.1% slower)


def test_stringio_requires_unicode():
    # io.StringIO only accepts str, so should return True
    sio = io.StringIO()
    codeflash_output = file_requires_unicode(sio)  # 1.43μs -> 656ns (117% faster)


def test_file_opened_in_binary_mode_does_not_require_unicode(tmp_path):
    # File opened in binary mode accepts bytes
    f = (tmp_path / "test.bin").open("wb")
    codeflash_output = file_requires_unicode(f)  # 897ns -> 1.06μs (15.6% slower)
    f.close()


def test_file_opened_in_text_mode_requires_unicode(tmp_path):
    # File opened in text mode only accepts str
    f = (tmp_path / "test.txt").open("w")
    codeflash_output = file_requires_unicode(f)  # 1.81μs -> 739ns (146% faster)
    f.close()


def test_custom_file_like_object_accepts_bytes():
    # Custom object that accepts bytes in write
    class BytesOnly:
        def write(self, data):
            if not isinstance(data, (bytes, bytearray)):
                raise TypeError("Only bytes allowed")
            return len(data)

    obj = BytesOnly()
    codeflash_output = file_requires_unicode(obj)  # 1.31μs -> 1.50μs (12.1% slower)


def test_custom_file_like_object_accepts_str():
    # Custom object that accepts str in write
    class StrOnly:
        def write(self, data):
            if not isinstance(data, str):
                raise TypeError("Only str allowed")
            return len(data)

    obj = StrOnly()
    codeflash_output = file_requires_unicode(obj)  # 1.75μs -> 1.83μs (4.10% slower)


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


def test_write_method_raises_other_exception():
    # If write raises something other than TypeError, should not be caught
    class RaisesValueError:
        def write(self, data):
            raise ValueError("Some other error")

    obj = RaisesValueError()
    with pytest.raises(ValueError):
        file_requires_unicode(obj)  # 1.46μs -> 1.58μs (7.63% slower)


def test_write_method_accepts_anything():
    # Accepts both str and bytes, should not raise TypeError
    class AcceptsAnything:
        def write(self, data):
            return len(str(data))

    obj = AcceptsAnything()
    codeflash_output = file_requires_unicode(obj)  # 1.46μs -> 1.72μs (15.0% slower)


def test_write_method_is_missing():
    # Object without write method should raise AttributeError
    class NoWrite:
        pass

    obj = NoWrite()
    with pytest.raises(AttributeError):
        file_requires_unicode(obj)  # 1.82μs -> 1.95μs (6.82% slower)


def test_write_method_accepts_none():
    # Write method that accepts None, but not bytes
    class WriteNoneOnly:
        def write(self, data):
            if data is not None:
                raise TypeError("Only None allowed")
            return 0

    obj = WriteNoneOnly()
    codeflash_output = file_requires_unicode(obj)  # 1.42μs -> 1.74μs (18.3% slower)


def test_write_method_accepts_bytearray():
    # Accepts bytearray but not bytes
    class WriteBytearrayOnly:
        def write(self, data):
            if not isinstance(data, bytearray):
                raise TypeError("Only bytearray allowed")
            return len(data)

    obj = WriteBytearrayOnly()
    codeflash_output = file_requires_unicode(obj)  # 1.67μs -> 1.89μs (11.8% slower)


def test_write_method_accepts_memoryview():
    # Accepts memoryview but not bytes
    class WriteMemoryviewOnly:
        def write(self, data):
            if not isinstance(data, memoryview):
                raise TypeError("Only memoryview allowed")
            return len(data)

    obj = WriteMemoryviewOnly()
    codeflash_output = file_requires_unicode(obj)  # 1.75μs -> 1.89μs (7.46% slower)


def test_write_method_accepts_bytes_and_str():
    # Accepts both bytes and str
    class WriteBytesAndStr:
        def write(self, data):
            if not isinstance(data, (str, bytes)):
                raise TypeError("Only str or bytes allowed")
            return len(data)

    obj = WriteBytesAndStr()
    codeflash_output = file_requires_unicode(obj)  # 1.34μs -> 1.56μs (13.7% slower)


def test_write_method_accepts_empty_bytes_only():
    # Accepts only empty bytes
    class WriteEmptyBytesOnly:
        def write(self, data):
            if data != b"":
                raise TypeError("Only empty bytes allowed")
            return 0

    obj = WriteEmptyBytesOnly()
    codeflash_output = file_requires_unicode(obj)  # 782ns -> 1.04μs (24.6% slower)


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


def test_many_bytesio_objects():
    # Test with many BytesIO objects to check scalability
    bios = [io.BytesIO() for _ in range(500)]
    for bio in bios:
        codeflash_output = file_requires_unicode(bio)  # 75.5μs -> 89.0μs (15.2% slower)


def test_many_stringio_objects():
    # Test with many StringIO objects to check scalability
    sios = [io.StringIO() for _ in range(500)]
    for sio in sios:
        codeflash_output = file_requires_unicode(sio)  # 167μs -> 79.5μs (111% faster)


def test_large_custom_file_like_objects():
    # Create a list of custom file-like objects, half accept bytes, half accept str
    class BytesWriter:
        def write(self, data):
            if not isinstance(data, bytes):
                raise TypeError
            return len(data)

    class StrWriter:
        def write(self, data):
            if not isinstance(data, str):
                raise TypeError
            return len(data)

    objs = [BytesWriter() if i % 2 == 0 else StrWriter() for i in range(1000)]
    for i, obj in enumerate(objs):
        expected = False if i % 2 == 0 else True
        codeflash_output = file_requires_unicode(obj)  # 293μs -> 314μs (6.79% slower)


def test_large_file_opened_in_binary_and_text_mode(tmp_path):
    # Open many files in binary and text mode and test
    paths = [tmp_path / f"file_{i}" for i in range(100)]
    files_bin = [p.open("wb") for p in paths[:50]]
    files_txt = [p.open("w") for p in paths[50:]]
    for f in files_bin:
        codeflash_output = file_requires_unicode(f)  # 10.0μs -> 11.5μs (12.3% slower)
        f.close()
    for f in files_txt:
        codeflash_output = file_requires_unicode(f)  # 24.6μs -> 8.74μs (182% faster)
        f.close()


def test_large_custom_object_with_random_behavior():
    # Some objects randomly accept bytes or str, test all
    class RandomWriter:
        def __init__(self, accept_bytes):
            self.accept_bytes = accept_bytes

        def write(self, data):
            if self.accept_bytes and isinstance(data, bytes):
                return len(data)
            elif not self.accept_bytes and isinstance(data, str):
                return len(data)
            else:
                raise TypeError

    objs = [RandomWriter(bool(i % 2)) for i in range(1000)]
    for i, obj in enumerate(objs):
        expected = False if i % 2 else True
        codeflash_output = file_requires_unicode(obj)  # 322μs -> 356μs (9.59% slower)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import io

# imports
import pytest
from matplotlib.cbook import file_requires_unicode

# unit tests

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


def test_bytesio_does_not_require_unicode():
    # io.BytesIO accepts bytes, should return False
    f = io.BytesIO()
    codeflash_output = file_requires_unicode(f)  # 608ns -> 693ns (12.3% slower)


def test_stringio_requires_unicode():
    # io.StringIO only accepts str, should return True
    f = io.StringIO()
    codeflash_output = file_requires_unicode(f)  # 1.38μs -> 566ns (143% faster)


def test_file_opened_in_binary_mode_does_not_require_unicode(tmp_path):
    # File opened in binary mode accepts bytes, should return False
    file_path = tmp_path / "test.bin"
    with open(file_path, "wb") as f:
        codeflash_output = file_requires_unicode(f)  # 921ns -> 1.05μs (12.2% slower)


def test_file_opened_in_text_mode_requires_unicode(tmp_path):
    # File opened in text mode only accepts str, should return True
    file_path = tmp_path / "test.txt"
    with open(file_path, "w") as f:
        codeflash_output = file_requires_unicode(f)  # 1.87μs -> 607ns (208% faster)


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


def test_object_with_write_accepting_both_bytes_and_str():
    # Custom object that accepts both bytes and str
    class FlexibleWriter:
        def write(self, data):
            if not isinstance(data, (bytes, str)):
                raise TypeError
            return len(data)

    fw = FlexibleWriter()
    # Should not raise TypeError for bytes, so returns False
    codeflash_output = file_requires_unicode(fw)  # 1.36μs -> 1.50μs (9.63% slower)


def test_object_with_write_accepting_only_str():
    # Custom object that raises TypeError for bytes
    class StrOnlyWriter:
        def write(self, data):
            if isinstance(data, bytes):
                raise TypeError("bytes not allowed")
            return len(data)

    sow = StrOnlyWriter()
    codeflash_output = file_requires_unicode(sow)  # 1.70μs -> 1.87μs (8.89% slower)


def test_object_with_write_accepting_only_bytes():
    # Custom object that raises TypeError for str, but accepts bytes
    class BytesOnlyWriter:
        def write(self, data):
            if not isinstance(data, bytes):
                raise TypeError("only bytes allowed")
            return len(data)

    bow = BytesOnlyWriter()
    codeflash_output = file_requires_unicode(bow)  # 1.20μs -> 1.32μs (9.54% slower)


def test_object_with_write_raising_other_exception():
    # Custom object that raises ValueError for bytes, should not be caught
    class ValueErrorWriter:
        def write(self, data):
            if isinstance(data, bytes):
                raise ValueError("not a TypeError")
            return len(data)

    vew = ValueErrorWriter()
    # Should propagate the ValueError, not return True/False
    with pytest.raises(ValueError):
        file_requires_unicode(vew)  # 1.78μs -> 1.70μs (4.77% faster)


def test_object_with_write_not_implemented():
    # Custom object with write method that raises NotImplementedError
    class NotImplementedWriter:
        def write(self, data):
            raise NotImplementedError("not implemented")

    niw = NotImplementedWriter()
    # Should propagate NotImplementedError, not return True/False
    with pytest.raises(NotImplementedError):
        file_requires_unicode(niw)  # 1.52μs -> 1.72μs (11.7% slower)


def test_object_with_write_accepting_none():
    # Custom object that only accepts None, raises TypeError for bytes
    class NoneWriter:
        def write(self, data):
            if data is not None:
                raise TypeError("only None allowed")
            return 0

    nw = NoneWriter()
    codeflash_output = file_requires_unicode(nw)  # 1.66μs -> 1.79μs (7.47% slower)


def test_object_without_write_method():
    # Object with no write method
    class NoWrite:
        pass

    nw = NoWrite()
    # Should raise AttributeError
    with pytest.raises(AttributeError):
        file_requires_unicode(nw)  # 1.82μs -> 1.95μs (6.42% slower)


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


def test_many_bytesio_instances():
    # Test with many BytesIO instances to check scalability
    files = [io.BytesIO() for _ in range(500)]
    for f in files:
        codeflash_output = file_requires_unicode(f)  # 75.9μs -> 89.4μs (15.1% slower)


def test_many_stringio_instances():
    # Test with many StringIO instances to check scalability
    files = [io.StringIO() for _ in range(500)]
    for f in files:
        codeflash_output = file_requires_unicode(f)  # 167μs -> 80.1μs (109% faster)


def test_mixed_file_like_objects(tmp_path):
    # Test with a mix of text and binary files
    files = []
    for i in range(250):
        files.append(io.BytesIO())
        files.append(io.StringIO())
    for i, f in enumerate(files):
        if isinstance(f, io.BytesIO):
            codeflash_output = file_requires_unicode(f)
        else:
            codeflash_output = file_requires_unicode(f)


def test_large_custom_bytes_writer_list():
    # Test with many custom bytes-only writers
    class BytesOnlyWriter:
        def write(self, data):
            if not isinstance(data, bytes):
                raise TypeError("only bytes allowed")
            return len(data)

    writers = [BytesOnlyWriter() for _ in range(500)]
    for w in writers:
        codeflash_output = file_requires_unicode(w)  # 108μs -> 117μs (7.34% slower)


def test_large_custom_str_writer_list():
    # Test with many custom str-only writers
    class StrOnlyWriter:
        def write(self, data):
            if isinstance(data, bytes):
                raise TypeError("bytes not allowed")
            return len(data)

    writers = [StrOnlyWriter() for _ in range(500)]
    for w in writers:
        codeflash_output = file_requires_unicode(w)  # 161μs -> 171μs (5.76% slower)


# 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-file_requires_unicode-misbvyws and push.