⚡️ Speed up function load_json_from_string by 93,682%

[codeflash-ai]

📄 93,682% (936.82x) speedup for load_json_from_string in src/numpy_pandas/numerical_methods.py

⏱️ Runtime : 1.13 seconds → 1.21 milliseconds (best of 248 runs)

📝 Explanation and details

Here’s the optimized version of your program, focused on eliminating redundant parsing. Currently, you're re-parsing the same JSON string 1000 times using the relatively slow json.loads (pure Python after import and not the fastest).
A huge speedup can be gained by parsing once, then replicating using [obj.copy() for _ in range(1000)], since the objects are all the same. For most JSON objects, a shallow copy is sufficient and much faster.

If you really do need 1000 distinct copies (not references), use .copy(). If not, you can even just replicate references.
If you need to use a faster parser, orjson is installed and is dramatically faster (it's a C extension). However, orjson.loads returns immutable types and may not always produce dict, so let's stick to json if you want mutability unless told otherwise.

Here’s the rewritten, optimized function with explanations.

• If you truly need exactly-duplicate, independent but mutable objects in the list, .copy() is correct and fast for shallow dicts.
• If you need deep copies (nested structures):

  import copy
  def load_json_from_string(json_string: str) -> List[dict].
      obj = json.loads(json_string)
      return [copy.deepcopy(obj) for _ in range(1000)]
• For largest performance benefit: use orjson if possible (if you can handle slightly different types, e.g. dict vs. orjson types).

  import orjson
  def load_json_from_string(json_string: str) -> List[dict].
      # orjson.loads returns dict-like objects but not exactly `dict`, adjust if strictly needed
      obj = orjson.loads(json_string)
      return [obj.copy() for _ in range(1000)]

You may test which is fastest for your needs. All of these are massively faster than parsing the string 1000 times.

---

Summary:

• Avoid re-parsing the same JSON 1000 times — parse once, then copy.
• Use shallow or deep .copy() depending on your requirements.
• For maximum speed and if you can accept non-dict return types, consider using orjson.

💡 This modification will reduce your runtime by several orders of magnitude!

---

Comments:

• Preserved your function signature and comments (no comments were present to begin with).
• Added a single in-line comment explaining the optimization.

If you want an absolute minimal/fast case and it's OK to return the same object repeatedly (not copies), just.

But this does NOT create distinct dicts—they’re all the same object in memory.

---

Let me know if you need the orjson version or deepcopy for nested objects!

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 44 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, List

# imports
import pytest  # used for our unit tests
from src.numpy_pandas.numerical_methods import load_json_from_string

# unit tests

# -------------------------------
# 1. Basic Test Cases
# -------------------------------

def test_simple_object():
    # Test loading a simple JSON object
    s = '{"key": "value", "num": 1}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.18ms -> 3.46μs (34138% faster)

def test_simple_array():
    # Test loading a simple JSON array
    s = '[1, 2, 3, 4]'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.17ms -> 3.17μs (36824% faster)

def test_nested_object():
    # Test loading a nested JSON object
    s = '{"outer": {"inner": {"x": 10}}, "arr": [1,2,3]}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.63ms -> 4.04μs (40251% faster)

def test_boolean_and_null():
    # Test loading JSON with booleans and null
    s = '{"a": true, "b": false, "c": null}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.14ms -> 3.38μs (33615% faster)

def test_number_types():
    # Test loading JSON with integers and floats
    s = '{"int": 1, "float": 2.5, "neg": -3}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.40ms -> 3.71μs (37759% faster)

def test_string_with_escapes():
    # Test loading JSON string with escape sequences
    s = r'{"text": "Line1\nLine2\tTabbed\\Backslash\"Quote"}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.25ms -> 3.46μs (36175% faster)

# -------------------------------
# 2. Edge Test Cases
# -------------------------------

def test_empty_object():
    # Test loading an empty JSON object
    s = '{}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 879μs -> 2.62μs (33386% faster)

def test_empty_array():
    # Test loading an empty JSON array
    s = '[]'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 886μs -> 2.67μs (33129% faster)

def test_empty_string():
    # Test loading an empty string (should fail)
    s = ''
    with pytest.raises(json.JSONDecodeError):
        load_json_from_string(s)

def test_whitespace_only():
    # Test loading a whitespace-only string (should fail)
    s = '   \n\t  '
    with pytest.raises(json.JSONDecodeError):
        load_json_from_string(s)

def test_invalid_json_missing_brace():
    # Test invalid JSON (missing closing brace)
    s = '{"key": 1'
    with pytest.raises(json.JSONDecodeError):
        load_json_from_string(s)

def test_invalid_json_extra_comma():
    # Test invalid JSON (trailing comma)
    s = '{"a":1,}'
    with pytest.raises(json.JSONDecodeError):
        load_json_from_string(s)

def test_non_string_input():
    # Test input that is not a string (should raise TypeError)
    with pytest.raises(TypeError):
        load_json_from_string(123)  # type: ignore

def test_unicode_characters():
    # Test JSON with unicode characters
    s = '{"emoji": "😀", "cyrillic": "Привет"}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.20ms -> 3.79μs (31453% faster)

def test_deeply_nested_json():
    # Test deeply nested JSON (but within reasonable depth)
    s = '{"a": {"b": {"c": {"d": {"e": 5}}}}}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.44ms -> 3.54μs (40529% faster)

def test_large_numbers():
    # Test JSON with very large integer and float values
    s = '{"bigint": 12345678901234567890, "bigfloat": 1.234567890123456e+30}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.51ms -> 4.25μs (35440% faster)

def test_json_array_of_mixed_types():
    # Test JSON array with mixed types
    s = '[1, "two", null, true, {"a": 3}]'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.26ms -> 3.42μs (36810% faster)

def test_json_with_comments_should_fail():
    # JSON with comments is invalid and should fail
    s = '{ "a": 1 // comment }'
    with pytest.raises(json.JSONDecodeError):
        load_json_from_string(s)

def test_trailing_whitespace():
    # JSON with trailing whitespace should succeed
    s = '{"a": 1}    \n\t'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.05ms -> 3.00μs (34911% faster)

def test_leading_whitespace():
    # JSON with leading whitespace should succeed
    s = '   \n\t{"b":2}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.04ms -> 3.00μs (34436% faster)


def test_json_with_duplicate_keys():
    # JSON with duplicate keys: last one wins
    s = '{"a": 1, "a": 2}'
    codeflash_output = load_json_from_string(s); result = codeflash_output # 1.16ms -> 3.38μs (34141% faster)

# -------------------------------
# 3. Large Scale Test Cases
# -------------------------------

def test_large_flat_array():
    # Test loading a large flat array (1000 elements)
    arr = list(range(1000))
    s = json.dumps(arr)
    codeflash_output = load_json_from_string(s); result = codeflash_output # 73.0ms -> 71.8μs (101699% faster)

def test_large_object():
    # Test loading a large object with 1000 key-value pairs
    d = {f"key{i}": i for i in range(1000)}
    s = json.dumps(d)
    codeflash_output = load_json_from_string(s); result = codeflash_output # 207ms -> 204μs (101412% faster)

def test_large_nested_structure():
    # Test loading a structure with 1000 nested arrays (depth 10, width 100)
    arr = [list(range(100)) for _ in range(10)]
    s = json.dumps(arr)
    codeflash_output = load_json_from_string(s); result = codeflash_output # 72.0ms -> 73.5μs (97870% faster)

def test_large_json_string_size():
    # Test with a large string value (length 10,000)
    long_str = "a" * 10000
    s = json.dumps({"big": long_str})
    codeflash_output = load_json_from_string(s); result = codeflash_output # 15.7ms -> 17.2μs (91035% faster)

def test_large_mixed_array():
    # Test a large array of mixed types (length 500)
    arr = []
    for i in range(500):
        if i % 5 == 0:
            arr.append(i)
        elif i % 5 == 1:
            arr.append(str(i))
        elif i % 5 == 2:
            arr.append(None)
        elif i % 5 == 3:
            arr.append(True)
        else:
            arr.append({"x": i})
    s = json.dumps(arr)
    codeflash_output = load_json_from_string(s); result = codeflash_output

def test_large_json_with_unicode():
    # Test a large array of unicode strings
    arr = ["😀" * 10 for _ in range(500)]
    s = json.dumps(arr)
    codeflash_output = load_json_from_string(s); result = codeflash_output # 157ms -> 154μs (102313% 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 typing import List

# imports
import pytest  # used for our unit tests
from src.numpy_pandas.numerical_methods import load_json_from_string

# unit tests

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

def test_simple_object():
    # Test parsing a simple JSON object
    json_str = '{"a": 1, "b": "test"}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.17ms -> 3.33μs (35100% faster)

def test_simple_array():
    # Test parsing a simple JSON array
    json_str = '[1, 2, 3]'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.10ms -> 3.04μs (35999% faster)

def test_nested_object():
    # Test parsing a nested JSON object
    json_str = '{"user": {"id": 1, "name": "Alice"}, "active": true}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.46ms -> 3.71μs (39178% faster)

def test_object_with_null():
    # Test parsing an object with a null value
    json_str = '{"key": null}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 996μs -> 2.96μs (33573% faster)

def test_array_of_objects():
    # Test parsing an array of objects
    json_str = '[{"id": 1}, {"id": 2}]'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.30ms -> 3.38μs (38288% faster)

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

def test_empty_object():
    # Test parsing an empty object
    json_str = '{}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 870μs -> 2.62μs (33046% faster)

def test_empty_array():
    # Test parsing an empty array
    json_str = '[]'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 876μs -> 2.62μs (33292% faster)

def test_whitespace_only():
    # Test parsing a JSON string with leading/trailing whitespace
    json_str = '   { "a": 1 }   '
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.04ms -> 3.08μs (33701% faster)

def test_invalid_json():
    # Test parsing an invalid JSON string (should raise ValueError)
    json_str = '{"a": 1,,}'
    with pytest.raises(ValueError):
        load_json_from_string(json_str)





def test_unicode_characters():
    # Test parsing JSON with unicode characters
    json_str = '{"text": "こんにちは世界"}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.07ms -> 3.58μs (29697% faster)

def test_escaped_characters():
    # Test parsing JSON with escaped characters
    json_str = '{"newline": "hello\\nworld"}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.15ms -> 3.42μs (33475% faster)

def test_large_numbers():
    # Test parsing JSON with large numbers
    json_str = '{"big": 12345678901234567890}'
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 1.12ms -> 3.21μs (34771% faster)

# ------------------------
# LARGE SCALE TEST CASES
# ------------------------

def test_large_object():
    # Test parsing a large object with many keys
    large_obj = {f"key{i}": i for i in range(1000)}
    json_str = json.dumps(large_obj)
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 209ms -> 204μs (102092% faster)

def test_large_array():
    # Test parsing a large array
    large_arr = list(range(1000))
    json_str = json.dumps(large_arr)
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 72.0ms -> 71.0μs (101376% faster)

def test_large_nested_structure():
    # Test parsing a large nested structure
    nested = {"a": [{"b": [i for i in range(100)]} for _ in range(10)]}
    json_str = json.dumps(nested)
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 73.1ms -> 75.0μs (97410% faster)

def test_deeply_nested_object():
    # Test parsing a deeply nested object
    nested = {}
    current = nested
    for i in range(50):
        current["a"] = {}
        current = current["a"]
    json_str = json.dumps(nested)
    codeflash_output = load_json_from_string(json_str); result = codeflash_output

def test_large_array_of_objects():
    # Test parsing a large array of objects
    arr = [{"id": i, "val": str(i)} for i in range(500)]
    json_str = json.dumps(arr)
    codeflash_output = load_json_from_string(json_str); result = codeflash_output # 177ms -> 167μs (105645% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from src.numpy_pandas.numerical_methods import load_json_from_string
import pytest

def test_load_json_from_string():
    with pytest.raises(JSONDecodeError, match='Expecting\\ value:\\ line\\ 1\\ column\\ 1\\ \\(char\\ 0\\)'):
        load_json_from_string('')

To edit these changes git checkout codeflash/optimize-load_json_from_string-mc9q73u8 and push.