⚡️ Speed up function templates_path by 2,654%

[codeflash-ai]

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

⏱️ Runtime : 76.9 microseconds → 2.79 microseconds (best of 70 runs)

📝 Explanation and details

The optimized code implements memoization using a global cache variable _templates_path that stores the computed Path object after the first call. This eliminates the expensive Path construction on subsequent calls.

Key optimization:

• Caching: The Path object is computed once and stored in _templates_path, avoiding repeated Path(ROOT_DIR) / "static" / "templates" operations
• Lazy initialization: The path is only computed when first needed, not at module import time

Why this creates a speedup:

• Path operations involve string manipulation and filesystem-related overhead that's expensive to repeat
• The original code reconstructs the same Path object every time (33.4μs per call)
• The optimized version only does this work once (40μs), then returns the cached object (0.46μs per subsequent call)

Performance characteristics:

• Single calls: Minimal improvement since initialization still occurs
• Multiple calls: Dramatic speedup (2000-3000%) as seen in the test results, where subsequent calls are ~30x faster
• Best for: Applications that call templates_path() multiple times, which is common for template-based systems

The 26x overall speedup comes from the test pattern calling the function multiple times, where all calls after the first benefit from the cached result.

✅ Correctness verification report:

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

ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
from higgsfield.internal.util import templates_path

# unit tests

# --- Basic Test Cases ---

def test_templates_path_type():
    # Test that the return type is always pathlib.Path
    codeflash_output = templates_path(); result = codeflash_output # 12.1μs -> 395ns (2973% faster)

def test_templates_path_correctness():
    # Test that the returned path is constructed correctly
    expected = Path(ROOT_DIR) / "static" / "templates"
    codeflash_output = templates_path(); actual = codeflash_output # 6.97μs -> 372ns (1774% faster)

def test_templates_path_is_absolute():
    # Test that the returned path is absolute
    codeflash_output = templates_path(); result = codeflash_output # 11.4μs -> 378ns (2909% faster)

# --- Edge Test Cases ---












def test_templates_path_static_and_templates_are_not_empty(monkeypatch):
    # Test that the returned path always ends with 'static/templates'
    codeflash_output = templates_path(); result = codeflash_output # 13.7μs -> 538ns (2444% faster)
    parts = result.parts

# --- Determinism Test ---

def test_templates_path_determinism():
    # Call templates_path multiple times and ensure the result is always the same
    codeflash_output = templates_path(); result1 = codeflash_output # 11.6μs -> 367ns (3067% faster)
    codeflash_output = templates_path(); result2 = codeflash_output # 6.21μs -> 190ns (3167% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os
import types
from pathlib import Path

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

# unit tests


@pytest.fixture
def patch_file(monkeypatch):
    """
    Fixture to patch __file__ in the module namespace where templates_path is defined.
    """
    def _patch_file(new_file):
        import builtins

        # Patch __file__ in the global namespace of templates_path
        monkeypatch.setattr(templates_path.__globals__, "__file__", new_file)
    return _patch_file

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











def test_templates_path_file_is_dir(monkeypatch, tmp_path):
    # Simulate __file__ as a directory path instead of a file
    dir_path = tmp_path / "higgsfield" / "internal"
    dir_path.mkdir(parents=True)
    monkeypatch.setattr(templates_path.__globals__, "__file__", str(dir_path))
    # os.path.abspath will treat it as a file path, so result will be based on the dir
    root_dir = os.path.dirname(os.path.dirname(os.path.abspath(str(dir_path))))
    expected = Path(root_dir) / "static" / "templates"
    codeflash_output = templates_path(); result = codeflash_output

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

@pytest.mark.parametrize("depth", [10, 100, 500, 999])
def test_templates_path_deeply_nested(patch_file, depth):
    # Simulate a deeply nested __file__ path
    # e.g. /a/b/c/d/.../higgsfield/internal/util.py
    parts = ["/"] + [f"dir{i}" for i in range(depth)] + ["higgsfield", "internal", "util.py"]
    fake_file = os.path.join(*parts)
    patch_file(fake_file)
    # The root_dir should be .../dir{depth}/higgsfield
    root_dir = os.path.dirname(os.path.dirname(os.path.abspath(fake_file)))
    expected = Path(root_dir) / "static" / "templates"
    codeflash_output = templates_path(); result = codeflash_output



#------------------------------------------------
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_zy687g4h/tmp0sel4elp/test_concolic_coverage.py::test_templates_path	14.9μs	552ns	2596%✅

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