⚡️ Speed up function templates_path by 2,968%

[codeflash-ai]

📄 2,968% (29.68x) speedup for templates_path in higgsfield/internal/util.py

⏱️ Runtime : 48.0 microseconds → 1.56 microsecondss (best of 72 runs)

📝 Explanation and details

The optimization implements lazy caching to avoid repeated Path object construction.

Key changes:

• Added a module-level cache variable _templates_path initialized to None
• First call computes and stores the path; subsequent calls return the cached Path object
• Added explicit import of ROOT_DIR for clarity

Why it's faster:
The original code calls Path(ROOT_DIR) / "static" / "templates" on every invocation, which creates new Path objects and performs string concatenation operations each time. The optimized version does this expensive computation only once and returns the pre-computed Path object on subsequent calls.

Performance characteristics:

• First call: Slightly slower due to the conditional check and assignment (38.9μs vs 40.7μs per hit originally)
• Subsequent calls: ~97% faster (827ns for the check + 465ns for the return vs 40.7μs for full computation)
• Overall speedup: 2967% improvement when the function is called multiple times

Best suited for: Applications where templates_path() is called repeatedly, as evidenced by the test results showing 3000%+ speedups on repeated calls. The caching strategy becomes more beneficial as the call frequency increases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os
from pathlib import Path

# imports
import pytest  # used for our unit tests
from higgsfield.internal.util import templates_path


@pytest.fixture
def patch_file(monkeypatch):
    """
    Fixture to patch __file__ in the templates_path function's module.
    """
    import sys
    import types

    # Create a dummy module to simulate __file__
    dummy_mod = types.ModuleType("dummy_util")
    code = (
        "import os\n"
        "from pathlib import Path\n"
        "def templates_path():\n"
        "    ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))\n"
        "    return Path(ROOT_DIR) / 'static' / 'templates'\n"
    )
    exec(code, dummy_mod.__dict__)
    yield dummy_mod

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















#------------------------------------------------
import os
from pathlib import Path

# imports
import pytest
from higgsfield.internal.util import templates_path


# function to test
# (Simulating the file's location for testing purposes)
def _mocked_templates_path(file_path: str) -> Path:
    """
    This is a helper to simulate the templates_path function as if it were defined in a module
    at file_path. This lets us test behavior for different __file__ values.
    """
    ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(file_path)))
    return Path(ROOT_DIR) / "static" / "templates"
from higgsfield.internal.util import templates_path

# unit tests

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

def test_templates_path_returns_path_object():
    """Test that templates_path returns a pathlib.Path object."""
    codeflash_output = templates_path(); result = codeflash_output # 12.6μs -> 350ns (3490% faster)

def test_templates_path_endswith_static_templates():
    """Test that the returned path ends with 'static/templates'."""
    codeflash_output = templates_path(); result = codeflash_output # 12.0μs -> 357ns (3264% faster)

def test_templates_path_is_absolute():
    """Test that the returned path is absolute."""
    codeflash_output = templates_path(); result = codeflash_output # 11.5μs -> 358ns (3103% faster)

def test_templates_path_correctness_with_known_file_location(tmp_path):
    """
    Test that templates_path computes the correct path given a known __file__ location.
    Simulate a file at /foo/bar/higgsfield/internal/util.py.
    """
    fake_file = os.path.join(str(tmp_path), "higgsfield", "internal", "util.py")
    os.makedirs(os.path.dirname(fake_file), exist_ok=True)
    with open(fake_file, "w") as f:
        f.write("# test file")
    # ROOT_DIR should be /foo/bar/higgsfield
    expected = Path(tmp_path) / "higgsfield" / "static" / "templates"
    result = _mocked_templates_path(fake_file)

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

def test_templates_path_with_symlinked_file(tmp_path):
    """
    Test behavior when __file__ is a symlink.
    """
    real_dir = tmp_path / "real" / "internal"
    os.makedirs(real_dir, exist_ok=True)
    real_file = real_dir / "util.py"
    real_file.write_text("# test file")
    symlink_dir = tmp_path / "link" / "internal"
    os.makedirs(symlink_dir.parent, exist_ok=True)
    symlink_dir.symlink_to(real_dir.parent)
    symlink_file = symlink_dir / "util.py"
    # The function should resolve the real path
    expected = tmp_path / "real" / "static" / "templates"
    result = _mocked_templates_path(str(symlink_file))

def test_templates_path_with_relative_file_path(tmp_path):
    """
    Test behavior when __file__ is a relative path.
    """
    rel_dir = "foo/bar/internal"
    abs_dir = tmp_path / "foo" / "bar" / "internal"
    os.makedirs(abs_dir, exist_ok=True)
    rel_file = os.path.join(rel_dir, "util.py")
    abs_file = abs_dir / "util.py"
    abs_file.write_text("# test file")
    # The function should resolve the relative path correctly
    cwd = os.getcwd()
    try:
        os.chdir(tmp_path)
        expected = tmp_path / "foo" / "bar" / "static" / "templates"
        result = _mocked_templates_path(rel_file)
    finally:
        os.chdir(cwd)

def test_templates_path_with_trailing_slash_in_file_path(tmp_path):
    """
    Test behavior when __file__ has a trailing slash (should be ignored).
    """
    file_path = tmp_path / "foo" / "bar" / "internal" / "util.py"
    os.makedirs(file_path.parent, exist_ok=True)
    file_path.write_text("# test file")
    # Add a trailing slash (unusual, but os.path.abspath should handle it)
    file_path_with_slash = str(file_path) + "/"
    expected = tmp_path / "foo" / "bar" / "static" / "templates"
    result = _mocked_templates_path(file_path_with_slash)

def test_templates_path_when_file_is_at_root(tmp_path):
    """
    Test when __file__ is at the filesystem root (simulate /util.py).
    """
    file_path = os.path.join("/", "util.py")
    # ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath("/util.py"))) == "/"
    expected = Path("/") / "static" / "templates"
    result = _mocked_templates_path(file_path)

def test_templates_path_with_nonexistent_file(tmp_path):
    """
    Test that the function does not check for file existence.
    """
    fake_file = tmp_path / "foo" / "bar" / "internal" / "util.py"
    # Do not create the file
    expected = tmp_path / "foo" / "bar" / "static" / "templates"
    result = _mocked_templates_path(str(fake_file))

def test_templates_path_with_unicode_directory(tmp_path):
    """
    Test behavior when the path contains unicode characters.
    """
    unicode_dir = tmp_path / "híggsfíeld" / "internål"
    os.makedirs(unicode_dir, exist_ok=True)
    file_path = unicode_dir / "util.py"
    file_path.write_text("# test file")
    expected = tmp_path / "híggsfíeld" / "static" / "templates"
    result = _mocked_templates_path(str(file_path))

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

def test_templates_path_with_deeply_nested_structure(tmp_path):
    """
    Test with a deeply nested directory structure (depth=50).
    """
    parts = ["foo"] + [f"level{i}" for i in range(48)] + ["internal"]
    deep_dir = tmp_path
    for part in parts:
        deep_dir = deep_dir / part
    os.makedirs(deep_dir, exist_ok=True)
    file_path = deep_dir / "util.py"
    file_path.write_text("# test file")
    # ROOT_DIR is two levels up from util.py
    expected = tmp_path
    for part in parts[:-2]:
        expected = expected / part
    expected = expected / "static" / "templates"
    result = _mocked_templates_path(str(file_path))

def test_templates_path_with_wide_directory(tmp_path):
    """
    Test with a directory containing many sibling folders (width=500).
    """
    base_dir = tmp_path / "foo"
    os.makedirs(base_dir, exist_ok=True)
    for i in range(500):
        os.makedirs(base_dir / f"sibling{i}", exist_ok=True)
    # Pick one sibling for the util.py
    util_dir = base_dir / "sibling123" / "internal"
    os.makedirs(util_dir, exist_ok=True)
    file_path = util_dir / "util.py"
    file_path.write_text("# test file")
    expected = base_dir / "sibling123" / "static" / "templates"
    result = _mocked_templates_path(str(file_path))

def test_templates_path_performance_large_number_of_calls(tmp_path):
    """
    Test performance and correctness by calling the function 500 times with different file paths.
    """
    base_dir = tmp_path / "foo"
    os.makedirs(base_dir, exist_ok=True)
    for i in range(500):
        util_dir = base_dir / f"bar{i}" / "internal"
        os.makedirs(util_dir, exist_ok=True)
        file_path = util_dir / "util.py"
        file_path.write_text("# test file")
        expected = base_dir / f"bar{i}" / "static" / "templates"
        result = _mocked_templates_path(str(file_path))
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from higgsfield.internal.util import templates_path

def test_templates_path():
    templates_path()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_3jg4m0fg/tmpt464ndzh/test_concolic_coverage.py::test_templates_path	12.0μs	500ns	2293%✅

To edit these changes git checkout codeflash/optimize-templates_path-mgll4hzu and push.