⚡️ Speed up method I18nData.tojson by 27%

[codeflash-ai]

📄 27% (0.27x) speedup for I18nData.tojson in gradio/i18n.py

⏱️ Runtime : 317 microseconds → 250 microseconds (best of 63 runs)

📝 Explanation and details

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

1. Added __slots__ declaration: The line __slots__ = ("key", "_type") prevents Python from creating a dynamic __dict__ for each instance. This reduces memory overhead and makes attribute access faster by storing attributes in a fixed-size array instead of a hash table.

2. Eliminated method call overhead: The tojson() method was changed from calling self.to_dict() to directly returning the dictionary {"__type__": self._type, "key": self.key}. This removes the function call overhead, which the line profiler shows was significant - the original tojson() took 2639.6ns per hit while the optimized version takes only 375.2ns per hit.

Why this works: In Python, method calls have overhead due to stack frame creation and lookup. Since tojson() was simply delegating to to_dict(), inlining the logic eliminates this overhead. Combined with __slots__ making attribute access (self._type, self.key) faster, the overall performance improves significantly.

Test results show consistent improvements: All test cases show 25-58% speedups, with particularly strong gains on edge cases like special characters (55.4% faster) and long keys (58.7% faster). The optimization scales well - the large-scale test with 1000 objects shows 25.3% improvement, indicating the benefits are maintained at scale.

Impact: This optimization is especially valuable for serialization-heavy workloads where tojson() might be called frequently, as each call now executes with significantly less overhead.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import json
from typing import Any

# imports
import pytest  # used for our unit tests
from gradio.i18n import I18nData

# unit tests

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

def test_tojson_basic_key():
    """Test tojson with a simple key string."""
    obj = I18nData("hello_world")
    expected = {"__type__": "translation_metadata", "key": "hello_world"}
    codeflash_output = obj.tojson() # 1.02μs -> 716ns (42.9% faster)

def test_tojson_empty_key():
    """Test tojson with an empty string as key."""
    obj = I18nData("")
    expected = {"__type__": "translation_metadata", "key": ""}
    codeflash_output = obj.tojson() # 944ns -> 684ns (38.0% faster)

def test_tojson_special_characters():
    """Test tojson with special characters in the key."""
    key = "greeting!@#$_-"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 956ns -> 615ns (55.4% faster)

def test_tojson_unicode_key():
    """Test tojson with unicode characters in the key."""
    key = "你好世界🌏"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 960ns -> 693ns (38.5% faster)

def test_tojson_numeric_key():
    """Test tojson with a numeric string as key."""
    key = "123456"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 980ns -> 649ns (51.0% faster)

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

def test_tojson_long_key():
    """Test tojson with a very long key string."""
    key = "a" * 1000
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 925ns -> 673ns (37.4% faster)

def test_tojson_key_with_newlines_and_tabs():
    """Test tojson with key containing newlines and tabs."""
    key = "line1\nline2\tline3"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 931ns -> 663ns (40.4% faster)

def test_tojson_key_with_quotes():
    """Test tojson with key containing single and double quotes."""
    key = 'He said: "Hello", then \'Goodbye\''
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 962ns -> 649ns (48.2% faster)

def test_tojson_key_with_escaped_characters():
    """Test tojson with key containing escaped characters."""
    key = "path\\to\\file"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 896ns -> 644ns (39.1% faster)

def test_tojson_key_with_null_char():
    """Test tojson with key containing null character."""
    key = "null\0char"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 912ns -> 638ns (42.9% faster)

def test_tojson_key_with_surrogate_pair():
    """Test tojson with key containing a surrogate pair (rare unicode)."""
    key = "emoji\U0001F600"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 937ns -> 664ns (41.1% faster)

def test_tojson_key_is_whitespace():
    """Test tojson with key containing only whitespace."""
    key = "     "
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 890ns -> 673ns (32.2% faster)

def test_tojson_key_is_newline():
    """Test tojson with key containing only newlines."""
    key = "\n\n\n"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 965ns -> 663ns (45.6% faster)

def test_tojson_key_is_tab():
    """Test tojson with key containing only tabs."""
    key = "\t\t\t"
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 923ns -> 642ns (43.8% faster)







def test_tojson_many_unique_keys():
    """Test tojson with many unique keys for scalability."""
    keys = [f"key_{i}" for i in range(1000)]
    objs = [I18nData(k) for k in keys]
    for idx, obj in enumerate(objs):
        expected = {"__type__": "translation_metadata", "key": f"key_{idx}"}
        codeflash_output = obj.tojson() # 284μs -> 226μs (25.3% faster)

def test_tojson_longest_possible_key():
    """Test tojson with a key at the edge of reasonable length (1000 chars)."""
    key = "x" * 1000
    obj = I18nData(key)
    expected = {"__type__": "translation_metadata", "key": key}
    codeflash_output = obj.tojson() # 1.08μs -> 678ns (58.7% faster)

def test_tojson_json_serialization_large():
    """Test that tojson output is JSON-serializable for many objects."""
    objs = [I18nData(str(i)) for i in range(1000)]
    json_list = [obj.tojson() for obj in objs]
    # Should not raise
    json_str = json.dumps(json_list)

def test_tojson_performance_large():
    """Test tojson performance for 1000 objects (should not be slow)."""
    import time
    objs = [I18nData(str(i)) for i in range(1000)]
    start = time.time()
    results = [obj.tojson() for obj in objs]
    duration = time.time() - start

def test_tojson_memory_usage_large():
    """Test tojson does not create excessive memory usage for 1000 objects."""
    # This is a sanity check, not an exact measurement
    import sys
    objs = [I18nData(str(i)) for i in range(1000)]
    total_size = sum(sys.getsizeof(obj.tojson()) for obj in objs)

# ----------- FUNCTIONALITY INTEGRITY TESTS -----------

def test_tojson_equality_vs_to_dict():
    """Test that tojson output matches to_dict output."""
    obj = I18nData("testkey")
    codeflash_output = obj.tojson() # 1.15μs -> 855ns (34.2% faster)

def test_tojson_not_string_output():
    """Test that tojson does not return a string."""
    obj = I18nData("testkey")

def test_tojson_output_is_dict():
    """Test that tojson always returns a dict."""
    obj = I18nData("testkey")

def test_tojson_output_keys():
    """Test that tojson output contains expected keys."""
    obj = I18nData("testkey")
    codeflash_output = obj.tojson(); output = codeflash_output # 1.07μs -> 800ns (34.1% faster)

def test_tojson_output_type_value():
    """Test that tojson output __type__ value is correct."""
    obj = I18nData("testkey")
    codeflash_output = obj.tojson(); output = codeflash_output # 1.04μs -> 729ns (42.8% faster)

def test_tojson_output_key_value():
    """Test that tojson output key value matches input."""
    key = "special_key"
    obj = I18nData(key)
    codeflash_output = obj.tojson(); output = codeflash_output # 1.07μs -> 729ns (46.5% 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 typing import Any

# imports
import pytest  # used for our unit tests
from gradio.i18n import I18nData

# unit tests

# --- Basic Test Cases ---

def test_tojson_basic_key():
    # Test with a simple key
    obj = I18nData("hello_world")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.09μs -> 807ns (35.4% faster)

def test_tojson_empty_key():
    # Test with an empty string key
    obj = I18nData("")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.08μs -> 740ns (46.4% faster)

def test_tojson_numeric_key():
    # Test with a numeric string key
    obj = I18nData("12345")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.03μs -> 748ns (37.4% faster)

def test_tojson_special_characters_key():
    # Test with special characters in key
    obj = I18nData("!@#$%^&*()_+-=[]{}|;':,.<>/?")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.06μs -> 705ns (50.8% faster)

def test_tojson_unicode_key():
    # Test with unicode characters in key
    obj = I18nData("你好世界🌏")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.02μs -> 764ns (33.6% faster)

def test_tojson_key_with_spaces():
    # Test with a key that contains spaces
    obj = I18nData("hello world key")
    codeflash_output = obj.tojson(); result = codeflash_output # 985ns -> 737ns (33.6% faster)

# --- Edge Test Cases ---

def test_tojson_long_key():
    # Test with a very long key
    long_key = "a" * 1000
    obj = I18nData(long_key)
    codeflash_output = obj.tojson(); result = codeflash_output # 1.03μs -> 771ns (33.9% faster)

def test_tojson_key_with_newlines_and_tabs():
    # Test with key containing newlines and tabs
    obj = I18nData("line1\nline2\tline3")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.04μs -> 723ns (43.6% faster)

def test_tojson_key_with_null_char():
    # Test with key containing null character
    obj = I18nData("null\0char")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.01μs -> 766ns (32.4% faster)

def test_tojson_key_is_str_type():
    # Test that key is always str type in output
    obj = I18nData("test")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.07μs -> 773ns (38.8% faster)

def test_tojson_type_field_immutable():
    # Changing _type should affect output
    obj = I18nData("test")
    obj._type = "custom_type"
    codeflash_output = obj.tojson(); result = codeflash_output # 1.06μs -> 727ns (46.4% faster)

def test_tojson_multiple_instances_independent():
    # Test that multiple instances do not interfere with each other
    obj1 = I18nData("key1")
    obj2 = I18nData("key2")

def test_tojson_repr_and_str_consistency():
    # __str__ and __repr__ should be consistent
    obj = I18nData("foo")


def test_tojson_dict_structure():
    # Ensure returned dict only has expected keys
    obj = I18nData("test")
    codeflash_output = obj.tojson(); result = codeflash_output # 1.14μs -> 821ns (39.3% faster)

# --- Large Scale Test Cases ---

def test_tojson_many_instances():
    # Test creating many instances and calling tojson
    keys = [f"key_{i}" for i in range(1000)]  # 1000 unique keys
    objs = [I18nData(k) for k in keys]
    results = [obj.tojson() for obj in objs]

def test_tojson_large_key_size():
    # Test with a key of maximum reasonable size (1000 chars)
    key = "x" * 1000
    obj = I18nData(key)
    codeflash_output = obj.tojson(); result = codeflash_output # 1.09μs -> 809ns (34.7% faster)

def test_tojson_performance_large_scale():
    # Test that tojson runs quickly on 1000 objects
    import time
    keys = [str(i) for i in range(1000)]
    objs = [I18nData(k) for k in keys]
    start = time.time()
    results = [obj.tojson() for obj in objs]
    end = time.time()
    # Validate all outputs
    for i, res in enumerate(results):
        pass

def test_tojson_stress_with_special_keys():
    # Test with 1000 keys containing special unicode and escape chars
    keys = [f"key_{i}_\n_\t_🌏" for i in range(1000)]
    objs = [I18nData(k) for k in keys]
    results = [obj.tojson() for obj in objs]
    for i, res in enumerate(results):
        pass
# 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-I18nData.tojson-mhlmpjdn and push.