⚡️ Speed up function embedding_from_b64 by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for embedding_from_b64 in modules/textual_inversion/image_embedding.py

⏱️ Runtime : 1.08 milliseconds → 995 microseconds (best of 146 runs)

📝 Explanation and details

The optimization adds an explicit UTF-8 decoding step (d.decode('utf-8')) before passing the data to json.loads(). While json.loads() can accept both bytes and strings in Python 3.6+, passing a decoded string is more efficient than letting the JSON parser handle the bytes internally.

Key changes:

• Explicitly decode the base64-decoded bytes to UTF-8 string before JSON parsing
• This eliminates internal decoding overhead within the JSON parser

Why this improves performance:
The JSON parser has optimized code paths for string inputs versus bytes inputs. When given bytes, json.loads() must first decode them internally, adding overhead. By pre-decoding to UTF-8, we use the more direct string parsing path, reducing the per-call overhead by ~3-4 microseconds.

Performance characteristics from tests:

• Small JSON objects (simple dicts, lists, primitives): 17-24% faster
• Large structures (1000+ elements): 3-8% faster, with diminishing returns as JSON parsing dominates
• Unicode-heavy content: 13-17% faster, showing the UTF-8 decoding optimization is particularly effective for international text
• Error cases: 2-20% faster, as the decoding step fails faster than internal JSON parser decoding

The optimization is most effective for smaller payloads where the decoding overhead represents a larger fraction of total processing time.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import base64
import json

# imports
import pytest
from modules.textual_inversion.image_embedding import embedding_from_b64


# --- Define a minimal EmbeddingDecoder for testing ---
class EmbeddingDecoder(json.JSONDecoder):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
from modules.textual_inversion.image_embedding import embedding_from_b64

# ----------------------
# UNIT TESTS FOR embedding_from_b64
# ----------------------

# 1. BASIC TEST CASES

def test_simple_dict_encoding_decoding():
    # Basic test: dict with simple values
    obj = {"a": 1, "b": "foo", "c": [1, 2, 3]}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 15.3μs -> 12.3μs (24.2% faster)

def test_empty_dict():
    # Basic test: empty dict
    obj = {}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.1μs -> 9.04μs (23.2% faster)

def test_simple_list():
    # Basic test: list as top-level object
    obj = [1, 2, 3, 4, 5]
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.9μs -> 9.07μs (20.0% faster)

def test_string():
    # Basic test: string as top-level object
    obj = "hello world"
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.6μs -> 8.65μs (23.0% faster)

def test_integer():
    # Basic test: integer as top-level object
    obj = 42
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.3μs -> 8.40μs (22.2% faster)

def test_float():
    # Basic test: float as top-level object
    obj = 3.14159
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.7μs -> 8.90μs (20.2% faster)

def test_nested_structure():
    # Basic test: nested dict/list structure
    obj = {"x": [1, {"y": "z"}], "foo": {"bar": [2, 3]}}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 12.1μs -> 10.3μs (16.9% faster)

# 2. EDGE TEST CASES

def test_empty_string():
    # Edge: empty string should raise base64 error
    with pytest.raises(Exception):
        embedding_from_b64("") # 13.9μs -> 11.8μs (17.3% faster)

def test_invalid_base64():
    # Edge: string that's not valid base64 should raise error
    with pytest.raises(Exception):
        embedding_from_b64("!!!not_base64!!!") # 3.33μs -> 3.23μs (3.00% faster)

def test_base64_but_invalid_json():
    # Edge: valid base64, but not valid JSON
    garbage = b"not a json string"
    b64 = base64.b64encode(garbage).decode('ascii')
    with pytest.raises(json.JSONDecodeError):
        embedding_from_b64(b64) # 14.6μs -> 12.2μs (20.1% faster)

def test_base64_of_empty_json():
    # Edge: valid base64, valid empty JSON
    b64 = base64.b64encode(b'').decode('ascii')
    with pytest.raises(json.JSONDecodeError):
        embedding_from_b64(b64) # 13.9μs -> 11.5μs (21.1% faster)

def test_unicode_characters():
    # Edge: JSON with unicode characters
    obj = {"emoji": "😀", "text": "Привет мир"}
    json_str = json.dumps(obj, ensure_ascii=False)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 14.7μs -> 13.0μs (13.3% faster)

def test_json_with_null():
    # Edge: JSON containing null value
    obj = {"a": None}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.0μs -> 9.00μs (22.5% faster)

def test_json_with_boolean():
    # Edge: JSON containing boolean values
    obj = {"true_val": True, "false_val": False}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.3μs -> 9.33μs (20.8% faster)

def test_non_ascii_base64():
    # Edge: base64 string with non-ascii characters (should fail)
    b64 = "你好世界"
    with pytest.raises(Exception):
        embedding_from_b64(b64) # 3.22μs -> 3.03μs (6.34% faster)

def test_base64_with_padding_variations():
    # Edge: base64 with/without padding
    obj = {"foo": "bar"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    b64_no_padding = b64.rstrip("=")
    # Both should decode the same
    codeflash_output = embedding_from_b64(b64)
    codeflash_output = embedding_from_b64(b64_no_padding)

# 3. LARGE SCALE TEST CASES

def test_large_flat_list():
    # Large test: large flat list
    obj = list(range(1000))
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 53.3μs -> 50.2μs (6.21% faster)

def test_large_nested_structure():
    # Large test: deeply nested structure
    obj = {"a": [{"b": [i for i in range(100)]} for _ in range(10)]}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 53.3μs -> 50.6μs (5.34% faster)

def test_large_string():
    # Large test: very large string
    obj = "a" * 5000
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 22.3μs -> 20.0μs (11.6% faster)

def test_large_dict():
    # Large test: large dict with many keys
    obj = {f"key_{i}": i for i in range(500)}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 78.8μs -> 76.0μs (3.64% faster)

def test_large_mixed_types():
    # Large test: mix of types in a big structure
    obj = {
        "ints": list(range(100)),
        "floats": [float(i) for i in range(100)],
        "strings": [str(i) for i in range(100)],
        "bools": [True, False] * 50,
        "nested": [{"x": i, "y": [j for j in range(10)]} for i in range(10)],
    }
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 39.1μs -> 36.7μs (6.64% faster)

# 4. ADDITIONAL EDGE CASES

def test_base64_with_whitespace():
    # Edge: base64 with whitespace/newlines (legal in base64)
    obj = {"foo": "bar"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    # Insert whitespace
    b64_with_ws = b64[:5] + " \n\t" + b64[5:]
    codeflash_output = embedding_from_b64(b64_with_ws); result = codeflash_output # 11.1μs -> 9.39μs (17.7% faster)

def test_base64_of_json_array_with_nulls():
    # Edge: array with nulls
    obj = [None] * 100
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 13.0μs -> 11.4μs (14.2% faster)

def test_base64_of_json_object_with_special_keys():
    # Edge: keys with special characters
    obj = {"sp ace": 1, "uni©ode": 2, "": 3}
    json_str = json.dumps(obj, ensure_ascii=False)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('ascii')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 12.6μs -> 11.0μs (14.2% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import base64
import json

# imports
import pytest  # used for our unit tests
from modules.textual_inversion.image_embedding import embedding_from_b64


# --- Function to test ---
# Minimal EmbeddingDecoder for json.loads compatibility
class EmbeddingDecoder(json.JSONDecoder):
    pass
from modules.textual_inversion.image_embedding import embedding_from_b64

# --- Unit Tests ---

# 1. Basic Test Cases

def test_basic_valid_dict():
    # Test with a simple JSON dict encoded as base64
    obj = {"a": 1, "b": "text"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.1μs -> 9.30μs (19.7% faster)

def test_basic_valid_list():
    # Test with a simple JSON list encoded as base64
    obj = [1, 2, 3, "foo"]
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.5μs -> 8.77μs (19.5% faster)

def test_basic_valid_string():
    # Test with a simple JSON string
    obj = "hello world"
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 9.91μs -> 8.24μs (20.2% faster)

def test_basic_valid_number():
    # Test with a simple JSON number
    obj = 12345
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.0μs -> 8.14μs (22.9% faster)

def test_basic_valid_boolean():
    # Test with a simple JSON boolean
    obj = True
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 9.48μs -> 8.09μs (17.3% faster)

def test_basic_valid_null():
    # Test with a simple JSON null
    obj = None
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 9.85μs -> 8.03μs (22.6% faster)

# 2. Edge Test Cases

def test_empty_string():
    # Edge case: empty string (invalid base64)
    with pytest.raises(Exception):
        embedding_from_b64("") # 14.3μs -> 12.3μs (16.5% faster)

def test_invalid_base64():
    # Edge case: not a base64 string
    with pytest.raises(Exception):
        embedding_from_b64("not_base64!") # 3.31μs -> 3.23μs (2.41% faster)

def test_base64_not_json():
    # Edge case: base64 of a non-JSON string
    raw = "just some text"
    b64 = base64.b64encode(raw.encode('utf-8')).decode('utf-8')
    with pytest.raises(json.JSONDecodeError):
        embedding_from_b64(b64) # 15.3μs -> 12.7μs (20.7% faster)

def test_base64_json_with_unicode():
    # Edge case: JSON with unicode characters
    obj = {"emoji": "😀", "unicode": "\u2603"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 12.6μs -> 10.7μs (17.7% faster)

def test_base64_json_with_escape_sequences():
    # Edge case: JSON with escape sequences
    obj = {"newline": "line1\nline2", "tab": "col1\tcol2"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.5μs -> 9.96μs (15.7% faster)

def test_base64_json_with_empty_dict():
    # Edge case: JSON with empty dict
    obj = {}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.5μs -> 8.61μs (22.5% faster)

def test_base64_json_with_empty_list():
    # Edge case: JSON with empty list
    obj = []
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 9.94μs -> 8.10μs (22.7% faster)

def test_base64_json_with_nested_structures():
    # Edge case: deeply nested JSON
    obj = {"a": [1, {"b": [2, {"c": [3, None]}]}]}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 11.7μs -> 9.97μs (16.9% faster)

def test_base64_json_with_large_numbers():
    # Edge case: large integer and float values
    obj = {"bigint": 2**60, "bigfloat": 1e100}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 12.9μs -> 11.1μs (16.6% faster)

def test_base64_json_with_special_characters():
    # Edge case: JSON containing special characters
    obj = {"special": "!@#$%^&*()_+-=[]{}|;':,.<>/?"}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 10.6μs -> 8.82μs (19.7% faster)




def test_large_dict():
    # Large dict with 1000 keys
    obj = {str(i): i for i in range(1000)}
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 131μs -> 131μs (0.103% faster)

def test_large_list():
    # Large list with 1000 elements
    obj = list(range(1000))
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 50.6μs -> 47.9μs (5.54% faster)

def test_large_nested_structure():
    # Large nested structure: list of dicts
    obj = [{"id": i, "val": [i, i*2, i*3]} for i in range(500)]
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 193μs -> 193μs (0.298% faster)

def test_large_string():
    # Large string of 10,000 characters
    obj = "a" * 10000
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 33.4μs -> 30.7μs (8.78% faster)

def test_large_unicode_string():
    # Large unicode string of 1000 emojis
    obj = "😀" * 1000
    json_str = json.dumps(obj)
    b64 = base64.b64encode(json_str.encode('utf-8')).decode('utf-8')
    codeflash_output = embedding_from_b64(b64); result = codeflash_output # 42.8μs -> 40.1μs (6.65% 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-embedding_from_b64-mh9tmh9b and push.