⚡️ Speed up function is_data_empty by 14%

[codeflash-ai]

📄 14% (0.14x) speedup for is_data_empty in marimo/_plugins/core/media.py

⏱️ Runtime : 985 microseconds → 866 microseconds (best of 187 runs)

📝 Explanation and details

The optimized code achieves a 13% speedup through two key optimizations:

1. String/Bytes Emptiness Check Optimization

• Changed data == "" and data == b"" to not data
• not data is faster because it directly checks the object's length at the C level, while data == "" requires creating a comparison with an empty literal
• This provides consistent speedups for string/bytes operations, particularly visible in the BytesIO test cases where string/bytes checks are bypassed more efficiently

2. BytesIO Type Check Optimization

• Added if type(data) is io.BytesIO: before the generic hasattr(data, "getbuffer") check
• Uses direct type comparison (type(data) is io.BytesIO) which is faster than isinstance() or hasattr()
• Removes the expensive cast(io.BytesIO, data) call for the common case of actual io.BytesIO objects
• The hasattr() fallback is retained for custom objects with getbuffer method

Performance Impact Analysis:

• BytesIO operations show the largest gains (7-24% faster) because they benefit from both optimizations - faster type checking and eliminated casting
• String/bytes operations show modest improvements (1-8% faster) from the not data optimization
• Custom objects may run slightly slower (7-16%) due to the additional type check, but these represent edge cases

The optimization is particularly effective for BytesIO-heavy workloads, which appear to be common based on the test results showing consistent improvements across all BytesIO test cases. The changes maintain identical behavior while optimizing the most common code paths.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
_plugins/core/test_media.py::test_is_data_empty	3.21μs	2.86μs	12.3%✅

🌀 Generated Regression Tests and Runtime

import io # used for BytesIO objects

imports

import pytest # used for our unit tests
from marimo._plugins.core.media import is_data_empty

unit tests

=========================

Basic Test Cases

=========================

def test_empty_string():
# Test with an empty string
codeflash_output = is_data_empty("") # 389ns -> 399ns (2.51% slower)

def test_nonempty_string():
# Test with a non-empty string
codeflash_output = is_data_empty("hello") # 376ns -> 387ns (2.84% slower)

def test_empty_bytes():
# Test with empty bytes
codeflash_output = is_data_empty(b"") # 483ns -> 478ns (1.05% faster)

def test_nonempty_bytes():
# Test with non-empty bytes
codeflash_output = is_data_empty(b"\x00\x01") # 487ns -> 517ns (5.80% slower)

def test_empty_bytesio():
# Test with an empty BytesIO object
bio = io.BytesIO()
codeflash_output = is_data_empty(bio) # 1.94μs -> 1.79μs (7.97% faster)

def test_nonempty_bytesio():
# Test with a non-empty BytesIO object
bio = io.BytesIO(b"abc")
codeflash_output = is_data_empty(bio) # 1.56μs -> 1.45μs (7.36% faster)

=========================

Edge Test Cases

=========================

def test_none_input():
# None is not considered empty by this function
codeflash_output = is_data_empty(None) # 504ns -> 690ns (27.0% slower)

def test_zero_integer():
# Integers are not considered empty, even if zero
codeflash_output = is_data_empty(0) # 509ns -> 659ns (22.8% slower)

def test_empty_list():
# Lists are not considered empty by this function
codeflash_output = is_data_empty([]) # 450ns -> 658ns (31.6% slower)

def test_empty_dict():
# Dicts are not considered empty by this function
codeflash_output = is_data_empty({}) # 507ns -> 698ns (27.4% slower)

def test_custom_object_with_getbuffer_zero():
# Custom object with getbuffer returning nbytes == 0
class DummyBuffer:
def getbuffer(self):
class Buffer:
nbytes = 0
return Buffer()
obj = DummyBuffer()
codeflash_output = is_data_empty(obj) # 6.98μs -> 7.58μs (7.86% slower)

def test_custom_object_with_getbuffer_nonzero():
# Custom object with getbuffer returning nbytes != 0
class DummyBuffer:
def getbuffer(self):
class Buffer:
nbytes = 5
return Buffer()
obj = DummyBuffer()
codeflash_output = is_data_empty(obj) # 5.59μs -> 6.66μs (16.0% slower)

def test_custom_object_without_getbuffer():
# Custom object without getbuffer method
class NoBuffer:
pass
obj = NoBuffer()
codeflash_output = is_data_empty(obj) # 699ns -> 871ns (19.7% slower)

def test_string_with_whitespace():
# String with whitespace is not empty
codeflash_output = is_data_empty(" ") # 386ns -> 429ns (10.0% slower)

def test_bytes_with_zero_byte():
# Bytes with a single zero byte is not empty
codeflash_output = is_data_empty(b"\x00") # 498ns -> 509ns (2.16% slower)

def test_bytesio_after_truncate():
# BytesIO after truncating to zero length
bio = io.BytesIO(b"abc")
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 1.85μs -> 1.64μs (13.1% faster)

def test_bytesio_after_seek_and_write():
# BytesIO after seeking and writing data
bio = io.BytesIO()
bio.write(b"xyz")
codeflash_output = is_data_empty(bio) # 1.45μs -> 1.22μs (18.3% faster)

def test_bytesio_after_seek_and_truncate():
# BytesIO after writing, seeking, and truncating
bio = io.BytesIO(b"abc")
bio.seek(0)
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 1.43μs -> 1.31μs (8.60% faster)

=========================

Large Scale Test Cases

=========================

def test_large_nonempty_string():
# Large non-empty string (1000 characters)
s = "a" * 1000
codeflash_output = is_data_empty(s) # 341ns -> 402ns (15.2% slower)

def test_large_empty_string():
# Large empty string (actually zero-length)
s = ""
codeflash_output = is_data_empty(s) # 388ns -> 370ns (4.86% faster)

def test_large_nonempty_bytes():
# Large non-empty bytes (1000 bytes)
b = b"x" * 1000
codeflash_output = is_data_empty(b) # 517ns -> 508ns (1.77% faster)

def test_large_empty_bytes():
# Large empty bytes (actually zero-length)
b = b""
codeflash_output = is_data_empty(b) # 490ns -> 492ns (0.407% slower)

def test_large_nonempty_bytesio():
# Large BytesIO object with 1000 bytes
bio = io.BytesIO(b"x" * 1000)
codeflash_output = is_data_empty(bio) # 2.25μs -> 2.00μs (12.3% faster)

def test_large_empty_bytesio():
# Large BytesIO object, but empty
bio = io.BytesIO()
codeflash_output = is_data_empty(bio) # 1.58μs -> 1.37μs (15.3% faster)

def test_bytesio_with_just_under_limit():
# BytesIO just under 1000 bytes
bio = io.BytesIO(b"x" * 999)
codeflash_output = is_data_empty(bio) # 1.68μs -> 1.56μs (7.50% faster)

def test_bytesio_with_exact_limit():
# BytesIO with exactly 1000 bytes
bio = io.BytesIO(b"x" * 1000)
codeflash_output = is_data_empty(bio) # 1.79μs -> 1.59μs (13.2% faster)

def test_bytesio_with_zero_bytes():
# BytesIO with zero bytes
bio = io.BytesIO(b"")
codeflash_output = is_data_empty(bio) # 1.44μs -> 1.28μs (12.6% faster)

def test_bytesio_with_large_truncate():
# BytesIO with large content, then truncate to zero
bio = io.BytesIO(b"x" * 1000)
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 1.40μs -> 1.25μs (11.7% faster)

=========================

Additional Edge Cases

=========================

def test_string_subclass():
# Subclass of str, empty
class MyStr(str):
pass
s = MyStr("")
codeflash_output = is_data_empty(s) # 479ns -> 360ns (33.1% faster)

def test_bytes_subclass():
# Subclass of bytes, non-empty
class MyBytes(bytes):
pass
b = MyBytes(b"abc")
codeflash_output = is_data_empty(b) # 660ns -> 687ns (3.93% slower)

def test_bytesio_subclass():
# Subclass of BytesIO, empty
class MyBytesIO(io.BytesIO):
pass
bio = MyBytesIO()
codeflash_output = is_data_empty(bio) # 2.06μs -> 2.24μs (8.18% slower)

def test_object_with_getbuffer_exception():
# Object with getbuffer raising exception
class BadBuffer:
def getbuffer(self):
raise RuntimeError("fail")
obj = BadBuffer()
# Should propagate the exception
with pytest.raises(RuntimeError):
is_data_empty(obj) # 1.76μs -> 1.94μs (9.44% 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 marimo._plugins.core.media import is_data_empty

unit tests

--- Basic Test Cases ---

def test_empty_string():
# Should return True for empty string
codeflash_output = is_data_empty("") # 398ns -> 410ns (2.93% slower)

def test_non_empty_string():
# Should return False for non-empty string
codeflash_output = is_data_empty("hello") # 391ns -> 371ns (5.39% faster)

def test_empty_bytes():
# Should return True for empty bytes
codeflash_output = is_data_empty(b"") # 474ns -> 467ns (1.50% faster)

def test_non_empty_bytes():
# Should return False for non-empty bytes
codeflash_output = is_data_empty(b"abc") # 522ns -> 485ns (7.63% faster)

def test_empty_bytesio():
# Should return True for empty io.BytesIO
empty_bio = io.BytesIO()
codeflash_output = is_data_empty(empty_bio) # 2.14μs -> 1.78μs (20.4% faster)

def test_non_empty_bytesio():
# Should return False for non-empty io.BytesIO
non_empty_bio = io.BytesIO(b"data")
codeflash_output = is_data_empty(non_empty_bio) # 1.56μs -> 1.41μs (10.7% faster)

--- Edge Test Cases ---

def test_string_with_whitespace():
# Should return False for whitespace string (not empty)
codeflash_output = is_data_empty(" ") # 344ns -> 394ns (12.7% slower)

def test_bytes_with_zero_byte():
# Should return False for bytes with a zero byte
codeflash_output = is_data_empty(b"\x00") # 505ns -> 486ns (3.91% faster)

def test_bytesio_with_zero_byte():
# Should return False for BytesIO with a zero byte
bio = io.BytesIO(b"\x00")
codeflash_output = is_data_empty(bio) # 1.92μs -> 1.66μs (15.6% faster)

def test_custom_object_with_getbuffer_empty():
# Should return True if custom object with getbuffer returns nbytes==0
class Dummy:
def getbuffer(self):
class Buffer:
nbytes = 0
return Buffer()
codeflash_output = is_data_empty(Dummy()) # 6.82μs -> 7.64μs (10.8% slower)

def test_custom_object_with_getbuffer_non_empty():
# Should return False if custom object with getbuffer returns nbytes>0
class Dummy:
def getbuffer(self):
class Buffer:
nbytes = 10
return Buffer()
codeflash_output = is_data_empty(Dummy()) # 5.93μs -> 6.62μs (10.3% slower)

def test_none_input():
# Should return False for None (not a recognized empty data type)
codeflash_output = is_data_empty(None) # 513ns -> 646ns (20.6% slower)

def test_integer_input():
# Should return False for integer input
codeflash_output = is_data_empty(0) # 493ns -> 665ns (25.9% slower)
codeflash_output = is_data_empty(42) # 289ns -> 345ns (16.2% slower)

def test_list_input():
# Should return False for list input, even if empty
codeflash_output = is_data_empty([]) # 463ns -> 642ns (27.9% slower)
codeflash_output = is_data_empty([1, 2, 3]) # 295ns -> 324ns (8.95% slower)

def test_object_without_getbuffer():
# Should return False for object without getbuffer
class NoBuffer:
pass
codeflash_output = is_data_empty(NoBuffer()) # 668ns -> 852ns (21.6% slower)

def test_bytesio_after_truncate():
# Should return True after truncating BytesIO to zero
bio = io.BytesIO(b"abc")
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 1.96μs -> 1.65μs (18.6% faster)

def test_bytesio_after_seek_and_write():
# Should return False after writing data to BytesIO
bio = io.BytesIO()
bio.write(b"abc")
codeflash_output = is_data_empty(bio) # 1.57μs -> 1.31μs (19.6% faster)

def test_string_subclass():
# Should treat string subclasses as strings
class MyStr(str):
pass
codeflash_output = is_data_empty(MyStr("")) # 442ns -> 383ns (15.4% faster)
codeflash_output = is_data_empty(MyStr("abc")) # 213ns -> 220ns (3.18% slower)

def test_bytes_subclass():
# Should treat bytes subclasses as bytes
class MyBytes(bytes):
pass
codeflash_output = is_data_empty(MyBytes(b"")) # 660ns -> 619ns (6.62% faster)
codeflash_output = is_data_empty(MyBytes(b"abc")) # 303ns -> 304ns (0.329% slower)

--- Large Scale Test Cases ---

def test_large_non_empty_string():
# Should return False for large non-empty string
large_str = "a" * 1000
codeflash_output = is_data_empty(large_str) # 366ns -> 363ns (0.826% faster)

def test_large_empty_string():
# Should return True for empty string, regardless of context
codeflash_output = is_data_empty("") # 355ns -> 372ns (4.57% slower)

def test_large_non_empty_bytes():
# Should return False for large non-empty bytes
large_bytes = b"a" * 1000
codeflash_output = is_data_empty(large_bytes) # 483ns -> 483ns (0.000% faster)

def test_large_empty_bytes():
# Should return True for empty bytes
codeflash_output = is_data_empty(b"") # 494ns -> 467ns (5.78% faster)

def test_large_non_empty_bytesio():
# Should return False for large BytesIO
large_bio = io.BytesIO(b"x" * 1000)
codeflash_output = is_data_empty(large_bio) # 2.44μs -> 2.07μs (17.6% faster)

def test_large_empty_bytesio():
# Should return True for empty BytesIO
large_empty_bio = io.BytesIO()
codeflash_output = is_data_empty(large_empty_bio) # 1.62μs -> 1.37μs (18.3% faster)

def test_bytesio_with_large_truncate():
# Should return True after truncating large BytesIO to zero
bio = io.BytesIO(b"x" * 1000)
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 1.53μs -> 1.23μs (24.6% faster)

def test_many_small_bytesio():
# Test multiple small BytesIO objects for performance and correctness
for _ in range(1000):
codeflash_output = is_data_empty(io.BytesIO()) # 381μs -> 323μs (17.9% faster)
codeflash_output = is_data_empty(io.BytesIO(b"1"))

def test_many_large_strings():
# Test many large strings for performance and correctness
for i in range(1000):
s = "a" * i
if i == 0:
codeflash_output = is_data_empty(s)
else:
codeflash_output = is_data_empty(s)

def test_bytesio_with_seek_and_truncate():
# Should return True after seek and truncate to 0
bio = io.BytesIO(b"abc" * 333)
bio.seek(0)
bio.truncate(0)
codeflash_output = is_data_empty(bio) # 2.05μs -> 1.84μs (11.7% faster)

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

#------------------------------------------------
from _io import BytesIO
from marimo._plugins.core.media import is_data_empty

def test_is_data_empty():
is_data_empty(BytesIO())

def test_is_data_empty_2():
is_data_empty('')

def test_is_data_empty_3():
is_data_empty(b'')

def test_is_data_empty_4():
is_data_empty(0)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_k_oa4bjc/tmpxo2uwspq/test_concolic_coverage.py::test_is_data_empty	1.60μs	1.38μs	16.6%✅
codeflash_concolic_k_oa4bjc/tmpxo2uwspq/test_concolic_coverage.py::test_is_data_empty_2	330ns	369ns	-10.6%⚠️
codeflash_concolic_k_oa4bjc/tmpxo2uwspq/test_concolic_coverage.py::test_is_data_empty_3	509ns	489ns	4.09%✅
codeflash_concolic_k_oa4bjc/tmpxo2uwspq/test_concolic_coverage.py::test_is_data_empty_4	537ns	711ns	-24.5%⚠️

To edit these changes git checkout codeflash/optimize-is_data_empty-mhu2lxw0 and push.