⚡️ Speed up function serialize_recursively by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for serialize_recursively in panel/chat/utils.py

⏱️ Runtime : 6.45 milliseconds → 5.99 milliseconds (best of 38 runs)

📝 Explanation and details

The optimized code achieves a 7% speedup through several key performance improvements:

1. Early string handling optimization:
The most significant change is moving the isinstance(obj, str) check to the very beginning and immediately returning the string. This eliminates redundant type checking within the iterable handling path and provides massive speedups for string-heavy workloads (up to 284% faster for pure strings as shown in tests).

2. Function localization in loops:
Inside the iterable processing loop, the code localizes serialize_recursively and get_obj_label to local variables. This reduces global namespace lookups during recursive calls, providing 10-20% speedups for nested structures and iterables.

3. Improved attribute access pattern:
In get_obj_label, replacing hasattr + conditional assignment with getattr(obj, "name", "") is more efficient, eliminating a redundant attribute lookup and simplifying the logic flow.

4. List-based accumulation:
Changed from generator expression with tuple conversion to list accumulation (content.append()) followed by tuple(content). This reduces frame creation overhead for moderate to large iterables and improves cache locality.

5. Reordered conditional logic:
Moved the BytesIO type check before the decode check (isinstance(string, BytesIO) or hasattr(string, "decode")) to prioritize the faster isinstance check.

The optimizations are particularly effective for:

• String-heavy workloads (270-284% faster)
• Large nested structures (12-20% faster)
• Mixed-type iterables (10-45% faster for dicts/sets)
• Deep recursive calls where function lookup overhead compounds

These micro-optimizations compound well across recursive calls while maintaining identical functionality and output.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

from collections.abc import Iterable
from io import BytesIO
from textwrap import indent
from typing import Any

import param
# imports
import pytest
from panel.chat.utils import serialize_recursively


# Dummy Viewable for testing purposes
class Viewable:
    pass
from panel.chat.utils import serialize_recursively

# --- Unit tests ---

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

def test_serialize_int():
    # Test serialization of a simple integer
    codeflash_output = serialize_recursively(42) # 2.49μs -> 2.45μs (1.59% faster)

def test_serialize_float():
    # Test serialization of a simple float
    codeflash_output = serialize_recursively(3.14) # 3.82μs -> 3.65μs (4.51% faster)

def test_serialize_str():
    # Test serialization of a simple string
    codeflash_output = serialize_recursively("hello") # 2.12μs -> 556ns (281% faster)

def test_serialize_list_of_ints():
    # Test serialization of a list of integers
    codeflash_output = serialize_recursively([1, 2, 3]) # 9.87μs -> 8.96μs (10.2% faster)

def test_serialize_tuple_of_mixed_types():
    # Test serialization of a tuple with mixed types
    codeflash_output = serialize_recursively((1, "a", 3.5)) # 11.3μs -> 9.64μs (16.8% faster)

def test_serialize_nested_list():
    # Test serialization of a nested list
    codeflash_output = serialize_recursively([[1, 2], [3, 4]]) # 15.1μs -> 13.4μs (12.4% faster)

def test_serialize_singleton_tuple():
    # Test serialization of a singleton tuple
    codeflash_output = serialize_recursively((42,)) # 4.83μs -> 4.06μs (18.9% faster)

def test_serialize_singleton_list():
    # Test serialization of a singleton list
    codeflash_output = serialize_recursively([99]) # 4.86μs -> 4.17μs (16.5% faster)

def test_serialize_with_prefix_flags_off():
    # Test serialization with both prefix flags set to False
    codeflash_output = serialize_recursively([1, 2], prefix_with_container_label=False, prefix_with_viewable_label=False) # 4.90μs -> 3.99μs (22.8% faster)

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

def test_serialize_empty_list():
    # Test serialization of an empty list
    codeflash_output = serialize_recursively([]) # 5.17μs -> 4.41μs (17.2% faster)

def test_serialize_empty_tuple():
    # Test serialization of an empty tuple
    codeflash_output = serialize_recursively(()) # 4.94μs -> 4.20μs (17.5% faster)

def test_serialize_empty_string():
    # Test serialization of an empty string
    codeflash_output = serialize_recursively("") # 1.88μs -> 489ns (284% faster)


def test_serialize_object_with_value_attribute():
    # Test serialization of an object with a 'value' attribute
    class ObjWithValue:
        value = 123
    codeflash_output = serialize_recursively(ObjWithValue()) # 74.3μs -> 73.8μs (0.767% faster)

def test_serialize_object_with_object_attribute():
    # Test serialization of an object with an 'object' attribute
    class ObjWithObject:
        object = "abc"
    codeflash_output = serialize_recursively(ObjWithObject()) # 65.9μs -> 63.9μs (3.09% faster)

def test_serialize_viewable_object():
    # Test serialization of a Viewable object
    class MyViewable(Viewable):
        def __init__(self, value):
            self.value = value
            self.name = "SpecialView"
    v = MyViewable("hello")
    # Should prefix with label and repr
    codeflash_output = serialize_recursively(v) # 66.8μs -> 65.8μs (1.50% faster)

def test_serialize_object_with_name_attribute():
    # Test serialization of an object with a 'name' attribute
    class NamedObj:
        def __init__(self):
            self.name = "CustomName"
    obj = NamedObj()
    codeflash_output = serialize_recursively(obj) # 66.7μs -> 68.1μs (1.97% slower)

def test_serialize_iterable_non_list_tuple():
    # Test serialization of a custom iterable (not list/tuple)
    class MyIterable:
        def __iter__(self):
            return iter([1, 2])
        def __len__(self):
            return 2
        def __str__(self):
            return "MyIterable"
    codeflash_output = serialize_recursively(MyIterable()); result = codeflash_output # 12.6μs -> 11.4μs (10.1% faster)

def test_serialize_dict():
    # Test serialization of a dict (should treat as iterable of keys)
    d = {"a": 1, "b": 2}
    # Should serialize as dict(
    #   a,
    #   b
    # )
    codeflash_output = serialize_recursively(d) # 8.50μs -> 6.14μs (38.5% faster)

def test_serialize_recursive_structure():
    # Test serialization of a recursive structure (self-referential)
    class Node:
        def __init__(self, value):
            self.value = value
            self.children = []
        def __iter__(self):
            return iter(self.children)
        def __len__(self):
            return len(self.children)
        def __str__(self):
            return f"Node({self.value})"
    root = Node(0)
    child = Node(1)
    root.children.append(child)
    # Should not recurse infinitely, but will only serialize children
    codeflash_output = serialize_recursively(root) # 10.4μs -> 9.23μs (13.0% faster)

def test_serialize_non_str_iterable():
    # Test serialization of a set
    s = {1, 2}
    # Sets are unordered, so check both possible outputs
    expected1 = "set(\n    1,\n    2\n)"
    expected2 = "set(\n    2,\n    1\n)"
    codeflash_output = serialize_recursively(s); result = codeflash_output # 9.01μs -> 8.21μs (9.74% faster)

def test_serialize_with_label_prefix_flags():
    # Test serialization with prefix_with_container_label = False
    codeflash_output = serialize_recursively([1, 2], prefix_with_container_label=False) # 5.32μs -> 4.68μs (13.7% faster)
    # Test serialization with prefix_with_viewable_label = False
    class MyViewable(Viewable):
        def __init__(self, value):
            self.value = value
    v = MyViewable("x")
    codeflash_output = serialize_recursively(v, prefix_with_viewable_label=False) # 69.7μs -> 70.3μs (0.855% slower)

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

def test_large_flat_list():
    # Test serialization of a large flat list
    data = list(range(1000))
    codeflash_output = serialize_recursively(data); result = codeflash_output # 516μs -> 521μs (0.958% slower)
    # Should contain all numbers in order
    for i in (0, 499, 999):
        pass

def test_large_nested_structure():
    # Test serialization of a large nested structure
    nested = [[i for i in range(10)] for _ in range(10)]
    codeflash_output = serialize_recursively(nested); result = codeflash_output # 90.5μs -> 87.7μs (3.12% faster)

def test_large_tuple_of_strings():
    # Test serialization of a large tuple of strings
    tup = tuple(str(i) for i in range(500))
    codeflash_output = serialize_recursively(tup); result = codeflash_output # 233μs -> 103μs (126% faster)

def test_large_custom_iterable():
    # Test serialization of a large custom iterable
    class BigIterable:
        def __iter__(self):
            return iter(range(1000))
        def __len__(self):
            return 1000
        def __str__(self):
            return "BigIterable"
    codeflash_output = serialize_recursively(BigIterable()); result = codeflash_output # 524μs -> 521μs (0.411% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from __future__ import annotations

from collections.abc import Iterable
from io import BytesIO
from textwrap import indent
from typing import Any

import param
# imports
import pytest  # used for our unit tests
from panel.chat.utils import serialize_recursively
from panel.viewable import Viewable

# unit tests

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

def test_serialize_int():
    # Basic integer
    codeflash_output = serialize_recursively(5) # 2.21μs -> 2.06μs (7.44% faster)

def test_serialize_float():
    # Basic float
    codeflash_output = serialize_recursively(3.14) # 3.52μs -> 3.39μs (3.83% faster)

def test_serialize_str():
    # Basic string
    codeflash_output = serialize_recursively("hello") # 1.80μs -> 487ns (270% faster)

def test_serialize_list_of_ints():
    # List of ints, should use label 'list'
    codeflash_output = serialize_recursively([1, 2, 3]) # 9.75μs -> 8.98μs (8.66% faster)

def test_serialize_tuple_of_mixed_types():
    # Tuple containing int, str, float
    codeflash_output = serialize_recursively((1, "a", 2.5)) # 11.2μs -> 9.44μs (19.0% faster)

def test_serialize_nested_list_tuple():
    # Nested list/tuple
    codeflash_output = serialize_recursively([1, (2, 3)]) # 12.8μs -> 11.5μs (11.6% faster)

def test_serialize_single_element_list():
    # Single element list
    codeflash_output = serialize_recursively([42]) # 4.99μs -> 4.12μs (21.0% faster)

def test_serialize_single_element_tuple():
    # Single element tuple
    codeflash_output = serialize_recursively((99,)) # 5.02μs -> 4.21μs (19.1% faster)

def test_serialize_empty_list():
    # Empty list
    codeflash_output = serialize_recursively([]) # 5.10μs -> 4.36μs (16.9% faster)

def test_serialize_empty_tuple():
    # Empty tuple
    codeflash_output = serialize_recursively(()) # 5.07μs -> 4.23μs (20.0% faster)

def test_serialize_list_with_str_and_int():
    # List with str and int
    codeflash_output = serialize_recursively(["foo", 42]) # 8.91μs -> 7.39μs (20.6% faster)

def test_serialize_str_iterable():
    # String should not be treated as iterable
    codeflash_output = serialize_recursively("abc") # 1.81μs -> 517ns (250% faster)

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

def test_serialize_bytesio_object(monkeypatch):
    # BytesIO object should trigger warning and use label
    bio = BytesIO(b"abc")
    # Patch param.main.param.warning to avoid actual warning
    monkeypatch.setattr(param.main.param, "warning", lambda msg: None)
    codeflash_output = serialize_recursively(bio) # 12.4μs -> 11.2μs (11.0% faster)

def test_serialize_object_with_value_attr():
    # Object with value attribute
    class Obj:
        def __init__(self, value):
            self.value = value
    o = Obj("custom_value")
    codeflash_output = serialize_recursively(o) # 71.5μs -> 71.0μs (0.747% faster)

def test_serialize_object_with_object_attr():
    # Object with object attribute
    class Obj:
        def __init__(self, obj):
            self.object = obj
    o = Obj("obj_value")
    codeflash_output = serialize_recursively(o) # 65.2μs -> 64.4μs (1.15% faster)

def test_serialize_object_with_decode_attr(monkeypatch):
    # Object with decode attribute should trigger warning and use label
    class Obj:
        def decode(self): pass
        def __str__(self): return "decode_obj"
    o = Obj()
    monkeypatch.setattr(param.main.param, "warning", lambda msg: None)
    codeflash_output = serialize_recursively(o) # 680μs -> 678μs (0.173% faster)

def test_serialize_custom_iterable():
    # Custom iterable should use its type name as label
    class MyIterable:
        def __iter__(self): return iter([1,2])
    codeflash_output = serialize_recursively(MyIterable()) # 13.3μs -> 12.0μs (10.2% faster)

def test_serialize_list_no_container_label():
    # prefix_with_container_label = False
    codeflash_output = serialize_recursively([1,2], prefix_with_container_label=False) # 5.54μs -> 4.61μs (20.1% faster)

def test_serialize_tuple_no_container_label():
    # prefix_with_container_label = False
    codeflash_output = serialize_recursively((1,2), prefix_with_container_label=False) # 5.27μs -> 4.31μs (22.3% faster)

def test_serialize_nested_container_label_false():
    # Nested containers with container label off
    codeflash_output = serialize_recursively([1, (2, 3)], prefix_with_container_label=False) # 7.04μs -> 5.99μs (17.5% faster)

def test_serialize_custom_named_object():
    # Object with name attribute, not starting with type name
    class Foo:
        def __init__(self): self.name = "special"
    codeflash_output = serialize_recursively(Foo()) # 74.7μs -> 73.6μs (1.60% faster)

def test_serialize_custom_named_object_type_prefix():
    # Object with name attribute starting with type name
    class Bar:
        def __init__(self): self.name = "Bar123"
    codeflash_output = serialize_recursively(Bar()) # 68.7μs -> 67.8μs (1.22% faster)



def test_serialize_none():
    # None should serialize to 'None'
    codeflash_output = serialize_recursively(None) # 2.36μs -> 2.32μs (1.46% faster)

def test_serialize_bool():
    # Bool should serialize to 'True' or 'False'
    codeflash_output = serialize_recursively(True) # 2.63μs -> 2.65μs (0.566% slower)
    codeflash_output = serialize_recursively(False) # 933ns -> 970ns (3.81% slower)

def test_serialize_set():
    # Set should use label 'set'
    s = {1,2}
    # Sets are unordered, so check both possible outputs
    codeflash_output = serialize_recursively(s); result = codeflash_output # 9.53μs -> 8.46μs (12.6% faster)

def test_serialize_frozenset():
    # Frozenset should use label 'frozenset'
    fs = frozenset([1,2])
    codeflash_output = serialize_recursively(fs); result = codeflash_output # 9.17μs -> 7.71μs (18.9% faster)

def test_serialize_dict():
    # Dict should use label 'dict' and serialize keys/values
    d = {'a': 1, 'b': 2}
    codeflash_output = serialize_recursively(d); result = codeflash_output # 8.45μs -> 5.79μs (45.9% faster)

def test_serialize_object_with_str():
    # Object with __str__ defined
    class Foo:
        def __str__(self): return "foo_str"
    codeflash_output = serialize_recursively(Foo()) # 72.8μs -> 70.6μs (3.21% faster)

def test_serialize_object_with_repr():
    # Object with __repr__ defined
    class Bar:
        def __repr__(self): return "bar_repr"
    codeflash_output = serialize_recursively(Bar()) # 65.1μs -> 65.5μs (0.622% slower)

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

def test_serialize_large_list():
    # Large list (up to 1000 elements)
    large = list(range(1000))
    codeflash_output = serialize_recursively(large); result = codeflash_output # 518μs -> 517μs (0.170% faster)
    for i in [0, 499, 999]:
        pass

def test_serialize_large_nested_list():
    # Nested list of 100 lists, each with 10 elements
    nested = [[j for j in range(10)] for i in range(100)]
    codeflash_output = serialize_recursively(nested); result = codeflash_output # 785μs -> 759μs (3.41% faster)
    # Spot check a few values
    for i in range(0, 100, 25):
        for j in [0, 5, 9]:
            pass

def test_serialize_large_tuple():
    # Large tuple (1000 elements)
    tup = tuple(range(1000))
    codeflash_output = serialize_recursively(tup); result = codeflash_output # 513μs -> 510μs (0.727% faster)
    for i in [0, 500, 999]:
        pass

def test_serialize_large_set():
    # Large set (1000 elements)
    s = set(range(1000))
    codeflash_output = serialize_recursively(s); result = codeflash_output # 511μs -> 513μs (0.329% slower)
    # Spot check a few values
    for i in [0, 500, 999]:
        pass

def test_serialize_large_dict_keys():
    # Large dict (1000 keys)
    d = {str(i): i for i in range(1000)}
    codeflash_output = serialize_recursively(d); result = codeflash_output # 447μs -> 189μs (136% faster)
    # Only keys are serialized
    for i in [0, 500, 999]:
        pass

def test_serialize_large_custom_iterable():
    # Custom iterable with 1000 elements
    class BigIter:
        def __iter__(self): return iter(range(1000))
    bi = BigIter()
    codeflash_output = serialize_recursively(bi); result = codeflash_output # 518μs -> 520μs (0.365% slower)
    for i in [0, 500, 999]:
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from panel.chat.utils import serialize_recursively

def test_serialize_recursively():
    serialize_recursively((0, ''), prefix_with_viewable_label=True, prefix_with_container_label=True)

def test_serialize_recursively_2():
    serialize_recursively('', prefix_with_viewable_label=True, prefix_with_container_label=True)

def test_serialize_recursively_3():
    serialize_recursively((), prefix_with_viewable_label=True, prefix_with_container_label=False)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_6n9z3qlh/tmpylo6xdlq/test_concolic_coverage.py::test_serialize_recursively	8.99μs	7.36μs	22.2%✅
codeflash_concolic_6n9z3qlh/tmpylo6xdlq/test_concolic_coverage.py::test_serialize_recursively_2	2.07μs	851ns	143%✅
codeflash_concolic_6n9z3qlh/tmpylo6xdlq/test_concolic_coverage.py::test_serialize_recursively_3	2.68μs	1.99μs	35.0%✅

To edit these changes git checkout codeflash/optimize-serialize_recursively-mhcc7xt3 and push.