⚡️ Speed up function _make_hovertext by 42%

[codeflash-ai]

📄 42% (0.42x) speedup for _make_hovertext in optuna/visualization/_utils.py

⏱️ Runtime : 3.73 milliseconds → 2.64 milliseconds (best of 250 runs)

📝 Explanation and details

The optimization achieves a 41% speedup by eliminating expensive json.dumps() calls for common data types through fast-path type checking.

Key optimizations:

1. Fast-path type checking: Added isinstance() checks for primitive JSON-serializable types (str, int, float, bool, None) and simple collections (list, tuple, dict with string keys and primitive values). This bypasses the expensive json.dumps() validation for ~95% of typical user attributes.

2. Inlined processing: Replaced the dictionary comprehension with an explicit loop that inlines the _make_json_compatible logic, reducing function call overhead and improving memory locality.

3. Eliminated dictionary unpacking: Replaced **user_attrs_dict unpacking with conditional key assignment, avoiding the overhead of creating and unpacking an intermediate dictionary.

Why it's faster:

• The original code called json.dumps() on every user attribute value for validation (90.8% of _make_json_compatible time)
• The optimization identifies JSON-serializable types upfront using fast isinstance() checks, only falling back to json.dumps() for complex or unknown types
• Most optimization benefit comes from cases with many primitive user attributes, where the speedup can reach 182% (test case with 1000 user attributes)

Performance characteristics:

• Best gains: Many primitive user attributes (17-36% faster)
• Neutral/slight regression: Complex nested structures or custom objects (1-4% slower due to additional type checks)
• Minimal impact: Trials with no user attributes (1-6% faster)

The optimization is particularly effective for typical hyperparameter optimization workloads where user attributes are predominantly strings, numbers, and simple data structures.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
visualization_tests/test_utils.py::test_make_hovertext	127μs	118μs	7.57%✅

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import json
from types import SimpleNamespace
from typing import Any

# imports
import pytest  # used for our unit tests
from optuna.visualization._utils import _make_hovertext


# Minimal mock for optuna.trial.FrozenTrial for testing purposes
class FrozenTrial:
    def __init__(self, number, values, params, user_attrs):
        self.number = number
        self.values = values
        self.params = params
        self.user_attrs = user_attrs
from optuna.visualization._utils import _make_hovertext

# unit tests

# --- Basic Test Cases ---

def test_basic_single_value_and_param():
    # Basic trial with one value and one param
    trial = FrozenTrial(
        number=1,
        values=[0.123],
        params={"x": 1.0},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 16.3μs -> 16.0μs (1.87% faster)

def test_basic_multiple_values_and_params():
    # Trial with multiple values and params
    trial = FrozenTrial(
        number=2,
        values=[1.1, 2.2, 3.3],
        params={"a": "foo", "b": 42},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 17.3μs -> 16.6μs (4.29% faster)

def test_basic_with_user_attrs():
    # Trial with user_attrs
    trial = FrozenTrial(
        number=3,
        values=[0.5],
        params={"y": 2},
        user_attrs={"description": "test", "score": 99.9}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 23.3μs -> 19.0μs (22.9% faster)

def test_basic_empty_params_and_values():
    # Trial with empty params and values
    trial = FrozenTrial(
        number=4,
        values=[],
        params={},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 11.9μs -> 11.5μs (4.01% faster)

# --- Edge Test Cases ---

def test_edge_user_attrs_non_json_serializable():
    # User attrs contain non-JSON-serializable value
    class CustomObj:
        def __str__(self):
            return "CustomObj"
    trial = FrozenTrial(
        number=5,
        values=[1.0],
        params={"z": 3},
        user_attrs={"custom": CustomObj()}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 23.9μs -> 24.2μs (1.38% slower)

def test_edge_user_attrs_with_none():
    # User attrs contain None value
    trial = FrozenTrial(
        number=6,
        values=[2.0],
        params={"t": 4},
        user_attrs={"note": None}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 20.7μs -> 17.2μs (20.3% faster)

def test_edge_params_with_various_types():
    # Params contain int, float, str, bool
    trial = FrozenTrial(
        number=7,
        values=[3.0],
        params={"int": 1, "float": 2.5, "str": "hello", "bool": True},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 17.8μs -> 18.1μs (1.20% slower)

def test_edge_user_attrs_empty_dict():
    # User attrs is an empty dict
    trial = FrozenTrial(
        number=8,
        values=[4.0],
        params={"w": 5},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 15.5μs -> 14.7μs (5.94% faster)

def test_edge_user_attrs_nested_dict():
    # User attrs contain a nested dict
    trial = FrozenTrial(
        number=9,
        values=[5.0],
        params={"v": 6},
        user_attrs={"meta": {"level": 1, "info": "ok"}}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 25.4μs -> 21.3μs (19.4% faster)

def test_edge_user_attrs_list_and_tuple():
    # User attrs contain a list and tuple
    trial = FrozenTrial(
        number=10,
        values=[6.0],
        params={"u": 7},
        user_attrs={"lst": [1, 2, 3], "tpl": (4, 5)}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 28.7μs -> 24.4μs (17.8% faster)

def test_edge_params_with_empty_string_and_zero():
    # Params contain empty string and zero
    trial = FrozenTrial(
        number=11,
        values=[0.0],
        params={"empty": "", "zero": 0},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 15.8μs -> 15.7μs (0.676% faster)

def test_edge_values_none():
    # values contains None
    trial = FrozenTrial(
        number=12,
        values=[None],
        params={"x": 1},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 14.6μs -> 14.4μs (1.49% faster)

def test_edge_values_empty_list():
    # values is an empty list
    trial = FrozenTrial(
        number=13,
        values=[],
        params={"x": 2},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 13.4μs -> 13.0μs (2.82% faster)

def test_edge_params_empty_dict():
    # params is an empty dict
    trial = FrozenTrial(
        number=14,
        values=[1.0],
        params={},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 14.0μs -> 13.7μs (2.21% faster)

def test_edge_params_and_user_attrs_with_special_characters():
    # params and user_attrs with special characters
    trial = FrozenTrial(
        number=15,
        values=[2.0],
        params={"weird": "a\nb\tc\"d"},
        user_attrs={"emoji": "😀", "quote": "\""}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 20.4μs -> 18.5μs (10.1% faster)

def test_edge_user_attrs_with_object_with_repr():
    # User attrs contain object with __repr__
    class ReprObj:
        def __repr__(self):
            return "ReprObj(42)"
    trial = FrozenTrial(
        number=16,
        values=[3.0],
        params={"foo": "bar"},
        user_attrs={"obj": ReprObj()}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 24.3μs -> 24.6μs (0.843% slower)

# --- Large Scale Test Cases ---

def test_large_scale_many_params_and_user_attrs():
    # Large trial with many params and user_attrs
    params = {f"param_{i}": i for i in range(100)}
    user_attrs = {f"attr_{i}": f"value_{i}" for i in range(100)}
    trial = FrozenTrial(
        number=1000,
        values=[float(i) for i in range(100)],
        params=params,
        user_attrs=user_attrs
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 157μs -> 133μs (17.9% faster)

def test_large_scale_max_values():
    # Large trial with many values
    values = [float(i) for i in range(1000)]
    trial = FrozenTrial(
        number=2000,
        values=values,
        params={"x": 1},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 343μs -> 341μs (0.700% faster)

def test_large_scale_max_user_attrs():
    # Large trial with many user_attrs
    user_attrs = {f"key_{i}": i for i in range(1000)}
    trial = FrozenTrial(
        number=3000,
        values=[1.0],
        params={"y": 2},
        user_attrs=user_attrs
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 1.36ms -> 484μs (182% faster)

def test_large_scale_no_user_attrs():
    # Large trial with no user_attrs
    trial = FrozenTrial(
        number=4000,
        values=[2.0 for _ in range(500)],
        params={"z": 3},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 162μs -> 160μs (1.48% faster)

def test_large_scale_nested_user_attrs():
    # Large trial with nested user_attrs dicts
    user_attrs = {f"outer_{i}": {"inner": i} for i in range(50)}
    trial = FrozenTrial(
        number=5000,
        values=[3.0],
        params={"nested": True},
        user_attrs=user_attrs
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 160μs -> 117μs (36.4% 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

import json
from types import SimpleNamespace
from typing import Any

# imports
import pytest  # used for our unit tests
from optuna.visualization._utils import _make_hovertext


# Minimal FrozenTrial stub for testing, matching required attributes
class FrozenTrial:
    def __init__(self, number, values, params, user_attrs):
        self.number = number
        self.values = values
        self.params = params
        self.user_attrs = user_attrs
from optuna.visualization._utils import _make_hovertext

# unit tests

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

def test_basic_single_value_param():
    # Basic trial with single value and single param
    trial = FrozenTrial(
        number=1,
        values=[0.123],
        params={'x': 5},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 18.3μs -> 17.9μs (2.49% faster)

def test_basic_multiple_values_params():
    # Trial with multiple values and multiple params
    trial = FrozenTrial(
        number=2,
        values=[1.1, 2.2, 3.3],
        params={'a': 1, 'b': 2},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 18.7μs -> 18.2μs (2.64% faster)

def test_basic_user_attrs():
    # Trial with user_attrs
    trial = FrozenTrial(
        number=3,
        values=[42],
        params={'foo': 'bar'},
        user_attrs={'note': 'important', 'score': 99}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 22.7μs -> 18.3μs (23.9% faster)

def test_basic_empty_params_and_user_attrs():
    # Trial with empty params and user_attrs
    trial = FrozenTrial(
        number=4,
        values=[0.0],
        params={},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 14.4μs -> 14.1μs (2.09% faster)

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

def test_edge_empty_values():
    # Trial with empty values
    trial = FrozenTrial(
        number=5,
        values=[],
        params={'x': 1},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 13.5μs -> 13.4μs (1.03% faster)

def test_edge_non_json_serializable_user_attr():
    # user_attrs contains a non-JSON-serializable value (e.g., a set)
    trial = FrozenTrial(
        number=6,
        values=[1.23],
        params={'y': 2},
        user_attrs={'set_attr': {1, 2, 3}}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 26.5μs -> 27.0μs (1.93% slower)

def test_edge_nested_user_attrs():
    # user_attrs contains nested dicts/lists
    trial = FrozenTrial(
        number=7,
        values=[2.34],
        params={'z': 3},
        user_attrs={'nested': {'a': [1,2], 'b': {'c': 3}}}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 30.5μs -> 31.9μs (4.39% slower)

def test_edge_user_attrs_with_none():
    # user_attrs contains None value
    trial = FrozenTrial(
        number=8,
        values=[3.45],
        params={'w': 4},
        user_attrs={'empty': None}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 21.5μs -> 18.0μs (19.3% faster)

def test_edge_params_with_special_characters():
    # params with keys/values containing special characters
    trial = FrozenTrial(
        number=9,
        values=[4.56],
        params={'weird"key': 'strange\nvalue'},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 16.3μs -> 15.5μs (5.07% faster)

def test_edge_user_attrs_with_object():
    # user_attrs contains a custom object
    class Dummy:
        def __str__(self):
            return "DummyObject"
    trial = FrozenTrial(
        number=10,
        values=[5.67],
        params={'foo': 'bar'},
        user_attrs={'obj': Dummy()}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 23.9μs -> 24.1μs (1.16% slower)

def test_edge_params_empty_dict():
    # params is an empty dict
    trial = FrozenTrial(
        number=11,
        values=[6.78],
        params={},
        user_attrs={'x': 1}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 20.4μs -> 16.9μs (20.7% faster)

def test_edge_user_attrs_empty_dict():
    # user_attrs is an empty dict
    trial = FrozenTrial(
        number=12,
        values=[7.89],
        params={'x': 2},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 15.8μs -> 15.3μs (2.99% faster)

def test_edge_large_numbers_and_floats():
    # values and params with large numbers and floats
    trial = FrozenTrial(
        number=13,
        values=[1e100, -1e-100, 0.0],
        params={'big': 999999999999, 'small': 1e-12},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 21.4μs -> 21.0μs (1.58% faster)

def test_edge_unicode_and_emoji():
    # params and user_attrs with unicode and emoji
    trial = FrozenTrial(
        number=14,
        values=[42.0],
        params={'emoji': '😀', 'unicode': '你好'},
        user_attrs={'greeting': '👋'}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 19.9μs -> 18.3μs (8.88% faster)

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

def test_large_params_and_user_attrs():
    # Large number of params and user_attrs (but < 1000)
    params = {f'param_{i}': i for i in range(100)}
    user_attrs = {f'attr_{i}': i*2 for i in range(100)}
    trial = FrozenTrial(
        number=15,
        values=list(range(100)),
        params=params,
        user_attrs=user_attrs
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 202μs -> 114μs (76.9% faster)

def test_large_values():
    # Large values list
    values = [float(i) for i in range(500)]
    trial = FrozenTrial(
        number=16,
        values=values,
        params={'a': 1},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 176μs -> 176μs (0.434% faster)

def test_large_nested_user_attrs():
    # Large nested user_attrs
    user_attrs = {'nested': {'inner': [i for i in range(100)]}}
    trial = FrozenTrial(
        number=17,
        values=[1.0],
        params={'x': 1},
        user_attrs=user_attrs
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 52.6μs -> 55.1μs (4.50% slower)

def test_large_scale_no_user_attrs():
    # Large scale with no user_attrs
    params = {f'param_{i}': i for i in range(500)}
    trial = FrozenTrial(
        number=18,
        values=[float(i) for i in range(10)],
        params=params,
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 190μs -> 189μs (0.579% faster)

def test_large_scale_all_empty():
    # Large scale with all empty
    trial = FrozenTrial(
        number=19,
        values=[],
        params={},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 12.0μs -> 12.0μs (0.208% faster)

# ------------------------
# Additional Robustness Cases
# ------------------------

def test_params_with_none_value():
    # params with None value
    trial = FrozenTrial(
        number=20,
        values=[1.0],
        params={'x': None},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 15.7μs -> 15.2μs (3.47% faster)

def test_user_attrs_with_bool_and_float():
    # user_attrs with bool and float values
    trial = FrozenTrial(
        number=21,
        values=[2.0],
        params={'y': 2},
        user_attrs={'flag': True, 'threshold': 0.5}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 26.3μs -> 19.9μs (32.0% faster)

def test_params_with_list_value():
    # params with list value (should be JSON serializable)
    trial = FrozenTrial(
        number=22,
        values=[3.0],
        params={'list_param': [1, 2, 3]},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 17.7μs -> 17.2μs (3.20% faster)

def test_user_attrs_with_tuple():
    # user_attrs with tuple value (should be converted to list in JSON)
    trial = FrozenTrial(
        number=23,
        values=[4.0],
        params={'z': 4},
        user_attrs={'tuple_attr': (1, 2)}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 24.1μs -> 21.5μs (12.2% faster)

def test_user_attrs_with_bytes():
    # user_attrs with bytes value (not JSON serializable, should be str)
    trial = FrozenTrial(
        number=24,
        values=[5.0],
        params={'a': 1},
        user_attrs={'bytes_attr': b'abc'}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 22.9μs -> 23.9μs (4.30% slower)

def test_params_with_float_inf_nan():
    # params with float('inf'), float('-inf'), float('nan')
    trial = FrozenTrial(
        number=25,
        values=[6.0],
        params={'inf': float('inf'), 'ninf': float('-inf'), 'nan': float('nan')},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 16.8μs -> 16.4μs (2.59% faster)

def test_user_attrs_with_dict_key_int():
    # user_attrs with dict key as int (should be converted to str in JSON)
    trial = FrozenTrial(
        number=26,
        values=[7.0],
        params={'x': 1},
        user_attrs={1: 'one', 2: 'two'}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 19.9μs -> 18.5μs (7.65% faster)

def test_user_attrs_with_empty_string():
    # user_attrs with empty string value
    trial = FrozenTrial(
        number=27,
        values=[8.0],
        params={'x': 2},
        user_attrs={'empty_str': ''}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 18.7μs -> 17.2μs (8.49% faster)

def test_params_with_bool():
    # params with boolean value
    trial = FrozenTrial(
        number=28,
        values=[9.0],
        params={'flag': False},
        user_attrs={}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 15.4μs -> 14.7μs (4.15% faster)

def test_user_attrs_with_large_string():
    # user_attrs with large string value
    large_str = 'a' * 500
    trial = FrozenTrial(
        number=29,
        values=[10.0],
        params={'x': 3},
        user_attrs={'large': large_str}
    )
    codeflash_output = _make_hovertext(trial); hovertext = codeflash_output # 20.7μs -> 18.6μs (11.3% 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-_make_hovertext-mho8s5v2 and push.