⚡️ Speed up function get_config by 5%

[codeflash-ai]

📄 5% (0.05x) speedup for get_config in modules/sysinfo.py

⏱️ Runtime : 25.8 milliseconds → 24.5 milliseconds (best of 154 runs)

📝 Explanation and details

The optimization achieves a 5% speedup through two key changes:

1. More efficient module import pattern: Changed from from modules import shared to import modules.shared as shared. This takes better advantage of Python's module caching system and reduces import overhead on repeated calls.

2. Control flow restructuring: Moved the successful return (return shared.opts.data) to an else block after the try/except, making the exception handling more precise and avoiding unnecessary code execution in the success path.

3. Minor attribute lookup optimization: Cached shared_cmd_options.cmd_opts.ui_settings_file in a variable to avoid repeated attribute traversal.

The profiler data shows the import statement (import modules.shared as shared) takes 99.5% of execution time in both versions, but the optimized version reduces this from 203.5ms to 202.1ms. The optimization is most effective for test cases where the shared module is successfully imported (showing 77-109% speedups in the annotated tests), while fallback scenarios see minimal improvement (0.1-1.7% gains) since they're dominated by file I/O operations.

This optimization particularly benefits scenarios with frequent calls to get_config() where the shared module is available, as evidenced by the deterministic test showing the second call improving from 2.22μs to 1.25μs.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import json
import os
import sys
import tempfile
import types

# imports
import pytest
from modules import shared_cmd_options
from modules.sysinfo import get_config

# unit tests

# Helper to patch modules.shared and modules.shared_cmd_options
class DummyShared:
    class Opts:
        def __init__(self, data):
            self.data = data
    def __init__(self, data):
        self.opts = DummyShared.Opts(data)

class DummyCmdOpts:
    def __init__(self, ui_settings_file):
        self.ui_settings_file = ui_settings_file

class DummySharedCmdOptions:
    def __init__(self, cmd_opts):
        self.cmd_opts = cmd_opts

# --- Basic Test Cases ---

def test_shared_opts_data_basic(monkeypatch):
    """Test: shared.opts.data returns a simple dict"""
    # Patch modules.shared
    dummy_shared = DummyShared({"foo": "bar"})
    sys.modules["modules.shared"] = dummy_shared
    # Patch modules.shared_cmd_options (should not be used)
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 7.22μs -> 3.47μs (108% faster)

def test_shared_opts_data_empty(monkeypatch):
    """Test: shared.opts.data returns an empty dict"""
    dummy_shared = DummyShared({})
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 5.67μs -> 3.01μs (88.7% faster)

def test_shared_opts_data_list(monkeypatch):
    """Test: shared.opts.data returns a list"""
    dummy_shared = DummyShared([1,2,3])
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 5.32μs -> 2.78μs (91.6% faster)

# --- Edge Test Cases ---

def test_shared_import_fails_valid_json(monkeypatch):
    """Test: shared import fails, valid JSON file is loaded"""
    # Remove modules.shared to simulate import failure
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    # Create a valid JSON file
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        json.dump({"config": 123}, tf)
        tf.flush()
        fname = tf.name
    # Patch modules.shared_cmd_options
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.18ms -> 1.17ms (0.577% faster)
    os.remove(fname)

def test_shared_import_fails_empty_json(monkeypatch):
    """Test: shared import fails, empty JSON file returns error"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        tf.write("")  # invalid JSON
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.14ms (0.466% faster)
    os.remove(fname)

def test_shared_import_fails_missing_file(monkeypatch):
    """Test: shared import fails, missing file returns error"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    missing_file = "non_existent_file.json"
    dummy_cmd_opts = DummyCmdOpts(missing_file)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.15ms (0.299% faster)

def test_shared_import_fails_invalid_json(monkeypatch):
    """Test: shared import fails, file contains invalid JSON"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        tf.write("{invalid json}")
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.14ms (0.652% faster)
    os.remove(fname)

def test_shared_opts_data_is_none(monkeypatch):
    """Test: shared.opts.data is None"""
    dummy_shared = DummyShared(None)
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 6.76μs -> 3.36μs (101% faster)

def test_shared_import_fails_cmd_opts_missing(monkeypatch):
    """Test: shared import fails, shared_cmd_options.cmd_opts missing attribute"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    class NoCmdOpts:
        pass
    sys.modules["modules.shared_cmd_options"] = NoCmdOpts()
    codeflash_output = get_config(); result = codeflash_output # 1.18ms -> 1.18ms (0.280% faster)

def test_shared_import_fails_cmd_opts_is_none(monkeypatch):
    """Test: shared import fails, shared_cmd_options.cmd_opts is None"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    class DummySCmdOpts:
        cmd_opts = None
    sys.modules["modules.shared_cmd_options"] = DummySCmdOpts()
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.14ms (0.516% faster)

# --- Large Scale Test Cases ---

def test_shared_opts_data_large_dict(monkeypatch):
    """Test: shared.opts.data returns a large dict"""
    large_dict = {str(i): i for i in range(1000)}
    dummy_shared = DummyShared(large_dict)
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 6.63μs -> 3.55μs (86.7% faster)

def test_shared_import_fails_large_json(monkeypatch):
    """Test: shared import fails, large JSON file is loaded"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    large_dict = {str(i): i for i in range(1000)}
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        json.dump(large_dict, tf)
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.19ms -> 1.17ms (1.20% faster)
    os.remove(fname)

def test_shared_import_fails_large_json_list(monkeypatch):
    """Test: shared import fails, large JSON file with a list"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    large_list = list(range(1000))
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        json.dump(large_list, tf)
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.16ms (0.813% faster)
    os.remove(fname)

def test_shared_opts_data_large_list(monkeypatch):
    """Test: shared.opts.data returns a large list"""
    large_list = list(range(1000))
    dummy_shared = DummyShared(large_list)
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 7.02μs -> 3.48μs (102% faster)

# --- Determinism Test ---

def test_shared_opts_data_deterministic(monkeypatch):
    """Test: shared.opts.data returns deterministic result"""
    dummy_shared = DummyShared({"a": 1, "b": 2})
    sys.modules["modules.shared"] = dummy_shared
    dummy_cmd_opts = DummyCmdOpts("unused.json")
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result1 = codeflash_output # 5.67μs -> 3.01μs (88.5% faster)
    codeflash_output = get_config(); result2 = codeflash_output # 2.22μs -> 1.25μs (77.2% faster)

# --- Miscellaneous Edge Cases ---

def test_shared_import_fails_json_is_number(monkeypatch):
    """Test: shared import fails, JSON file contains a number"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        tf.write("12345")
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.18ms -> 1.17ms (0.779% faster)
    os.remove(fname)

def test_shared_import_fails_json_is_string(monkeypatch):
    """Test: shared import fails, JSON file contains a string"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        json.dump("hello world", tf)
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.15ms (0.063% faster)
    os.remove(fname)

def test_shared_import_fails_json_is_null(monkeypatch):
    """Test: shared import fails, JSON file contains null"""
    if "modules.shared" in sys.modules:
        del sys.modules["modules.shared"]
    with tempfile.NamedTemporaryFile(mode="w+", delete=False) as tf:
        tf.write("null")
        tf.flush()
        fname = tf.name
    dummy_cmd_opts = DummyCmdOpts(fname)
    sys.modules["modules.shared_cmd_options"] = DummySharedCmdOptions(dummy_cmd_opts)
    codeflash_output = get_config(); result = codeflash_output # 1.16ms -> 1.14ms (1.67% faster)
    os.remove(fname)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import json
import os
import sys
import tempfile
import types

# imports
import pytest
from modules import shared_cmd_options
from modules.sysinfo import get_config


# Helper: Setup shared_cmd_options module
def setup_shared_cmd_options(ui_settings_file=None):
    mod = types.ModuleType("modules.shared_cmd_options")
    class CmdOpts:
        pass
    cmd_opts = CmdOpts()
    cmd_opts.ui_settings_file = ui_settings_file
    mod.cmd_opts = cmd_opts
    sys.modules["modules.shared_cmd_options"] = mod

# Helper: Setup shared module
def setup_shared(data):
    mod = types.ModuleType("modules.shared")
    class Opts:
        pass
    opts = Opts()
    opts.data = data
    mod.opts = opts
    sys.modules["modules.shared"] = mod

# --- Basic Test Cases ---

def test_shared_present_returns_data():
    """Test: shared module present, get_config returns shared.opts.data"""
    setup_shared_cmd_options(ui_settings_file="should_not_be_used.json")
    expected = {"foo": "bar", "baz": 123}
    setup_shared(expected)
    codeflash_output = get_config(); result = codeflash_output # 6.70μs -> 3.28μs (105% faster)

def test_shared_not_present_reads_ui_settings_file(tmp_path):
    """Test: shared module absent, reads ui_settings_file JSON"""
    # Remove shared module if present
    sys.modules.pop("modules.shared", None)
    # Create a temp JSON file
    config = {"alpha": 42, "beta": "test"}
    config_file = tmp_path / "config.json"
    config_file.write_text(json.dumps(config))
    setup_shared_cmd_options(ui_settings_file=str(config_file))
    codeflash_output = get_config(); result = codeflash_output # 1.18ms -> 1.17ms (0.600% faster)

def test_shared_not_present_and_ui_settings_file_missing():
    """Test: shared module absent, ui_settings_file does not exist"""
    sys.modules.pop("modules.shared", None)
    setup_shared_cmd_options(ui_settings_file="nonexistent_file.json")
    codeflash_output = get_config(); result = codeflash_output # 1.15ms -> 1.15ms (0.135% faster)

def test_shared_not_present_and_ui_settings_file_invalid_json(tmp_path):
    """Test: shared module absent, ui_settings_file contains invalid JSON"""
    sys.modules.pop("modules.shared", None)
    bad_json_file = tmp_path / "bad.json"
    bad_json_file.write_text("{not: valid json")
    setup_shared_cmd_options(ui_settings_file=str(bad_json_file))
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.17ms (0.247% faster)

# --- Edge Test Cases ---

def test_shared_opts_data_empty_dict():
    """Test: shared.opts.data is an empty dict"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    setup_shared({})
    codeflash_output = get_config(); result = codeflash_output # 6.73μs -> 3.30μs (104% faster)

def test_shared_opts_data_none():
    """Test: shared.opts.data is None"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    setup_shared(None)
    codeflash_output = get_config(); result = codeflash_output # 5.56μs -> 2.88μs (92.7% faster)

def test_shared_opts_data_large_types():
    """Test: shared.opts.data contains various types"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    expected = {
        "list": [1, 2, 3],
        "dict": {"a": 1},
        "str": "hello",
        "float": 1.23,
        "bool": True,
        "none": None
    }
    setup_shared(expected)
    codeflash_output = get_config(); result = codeflash_output # 5.24μs -> 2.71μs (93.4% faster)

def test_ui_settings_file_empty(tmp_path):
    """Test: ui_settings_file is empty file"""
    sys.modules.pop("modules.shared", None)
    empty_file = tmp_path / "empty.json"
    empty_file.write_text("")
    setup_shared_cmd_options(ui_settings_file=str(empty_file))
    codeflash_output = get_config(); result = codeflash_output # 1.19ms -> 1.18ms (0.558% faster)

def test_ui_settings_file_permission_denied(tmp_path):
    """Test: ui_settings_file exists but is not readable"""
    sys.modules.pop("modules.shared", None)
    file_path = tmp_path / "unreadable.json"
    file_path.write_text("{}")
    os.chmod(file_path, 0)  # Remove all permissions
    setup_shared_cmd_options(ui_settings_file=str(file_path))
    codeflash_output = get_config(); result = codeflash_output # 1.18ms -> 1.17ms (0.720% faster)
    os.chmod(file_path, 0o644)  # Restore permissions for cleanup

def test_ui_settings_file_is_directory(tmp_path):
    """Test: ui_settings_file points to a directory"""
    sys.modules.pop("modules.shared", None)
    setup_shared_cmd_options(ui_settings_file=str(tmp_path))
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.18ms (0.561% slower)

def test_ui_settings_file_is_symlink(tmp_path):
    """Test: ui_settings_file is a symlink to a valid file"""
    sys.modules.pop("modules.shared", None)
    target_file = tmp_path / "target.json"
    target_file.write_text(json.dumps({"x": 1}))
    symlink_file = tmp_path / "link.json"
    symlink_file.symlink_to(target_file)
    setup_shared_cmd_options(ui_settings_file=str(symlink_file))
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.17ms (0.566% faster)

# --- Large Scale Test Cases ---

def test_shared_opts_data_large_dict():
    """Test: shared.opts.data is a large dict"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    large_dict = {str(i): i for i in range(1000)}
    setup_shared(large_dict)
    codeflash_output = get_config(); result = codeflash_output # 7.45μs -> 3.57μs (109% faster)

def test_ui_settings_file_large_json(tmp_path):
    """Test: ui_settings_file contains large JSON dict"""
    sys.modules.pop("modules.shared", None)
    large_dict = {str(i): i for i in range(1000)}
    config_file = tmp_path / "large_config.json"
    config_file.write_text(json.dumps(large_dict))
    setup_shared_cmd_options(ui_settings_file=str(config_file))
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.17ms (0.108% slower)

def test_ui_settings_file_large_list_json(tmp_path):
    """Test: ui_settings_file contains large JSON list"""
    sys.modules.pop("modules.shared", None)
    large_list = list(range(1000))
    config_file = tmp_path / "large_list.json"
    config_file.write_text(json.dumps(large_list))
    setup_shared_cmd_options(ui_settings_file=str(config_file))
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.16ms (0.303% faster)

def test_shared_opts_data_large_nested():
    """Test: shared.opts.data is a large nested dict/list structure"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    large_nested = {
        "outer": [{"inner": [i for i in range(50)]} for _ in range(20)],
        "numbers": list(range(500))
    }
    setup_shared(large_nested)
    codeflash_output = get_config(); result = codeflash_output # 6.88μs -> 3.51μs (96.0% faster)

# --- Determinism and Robustness ---

def test_shared_import_raises_nonstandard_exception(monkeypatch):
    """Test: importing shared raises a non-standard exception, still handled"""
    setup_shared_cmd_options(ui_settings_file="unused.json")
    # Remove shared if present
    sys.modules.pop("modules.shared", None)
    # Monkeypatch __import__ to raise custom exception for 'modules.shared'
    orig_import = __import__
    def fake_import(name, *args, **kwargs):
        if name == "modules.shared":
            raise RuntimeError("Custom import error")
        return orig_import(name, *args, **kwargs)
    monkeypatch.setattr("builtins.__import__", fake_import)
    # Should fallback to reading ui_settings_file, which does not exist
    codeflash_output = get_config(); result = codeflash_output # 1.22ms -> 42.0μs (2800% faster)

def test_shared_cmd_options_missing_attribute(monkeypatch):
    """Test: shared_cmd_options.cmd_opts missing ui_settings_file attribute"""
    sys.modules.pop("modules.shared", None)
    mod = types.ModuleType("modules.shared_cmd_options")
    class CmdOpts:
        pass
    cmd_opts = CmdOpts()
    # Do not set ui_settings_file attribute
    mod.cmd_opts = cmd_opts
    sys.modules["modules.shared_cmd_options"] = mod
    codeflash_output = get_config(); result = codeflash_output # 1.17ms -> 1.18ms (1.14% slower)

To edit these changes git checkout codeflash/optimize-get_config-mh9ura0y and push.