⚡️ Speed up function get_patches_metadata by 45% in PR #690 (worktree/persist-optimization-patches)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #690

If you approve this dependent PR, these changes will be merged into the original PR branch worktree/persist-optimization-patches.

This PR will be automatically closed if the original PR is merged.

---

📄 45% (0.45x) speedup for get_patches_metadata in codeflash/code_utils/git_utils.py

⏱️ Runtime : 716 microseconds → 495 microseconds (best of 39 runs)

📝 Explanation and details

The optimized code achieves a 44% speedup through two key optimizations:

1. Added @lru_cache(maxsize=1) to get_patches_dir_for_project()

• This caches the Path object construction, avoiding repeated calls to get_git_project_id() and Path() creation
• The line profiler shows this function's total time dropped from 5.32ms to being completely eliminated from the hot path in get_patches_metadata()
• Since get_git_project_id() was already cached but still being called repeatedly, this second-level caching eliminates that redundancy

2. Replaced read_text() + json.loads() with open() + json.load()

• Using json.load() with a file handle is more efficient than reading the entire file into memory first with read_text() then parsing it
• This avoids the intermediate string creation and is particularly beneficial for larger JSON files
• Added explicit UTF-8 encoding for consistency

Performance Impact by Test Type:

• Basic cases (small/missing files): 45-65% faster - benefits primarily from the caching optimization
• Edge cases (malformed JSON): 38-47% faster - still benefits from both optimizations
• Large scale cases (1000+ patches, large files): 39-52% faster - the file I/O optimization becomes more significant with larger JSON files

The caching optimization provides the most consistent gains across all scenarios since it eliminates repeated expensive operations, while the file I/O optimization scales with file size.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import json
import os
import shutil
import tempfile
from functools import lru_cache
from pathlib import Path
from typing import Any

import git
# imports
import pytest  # used for our unit tests
from codeflash.code_utils.git_utils import get_patches_metadata

# --- Begin: Setup for testing environment ---

# We'll use a temporary directory for codeflash_cache_dir to avoid polluting user's environment
class DummyCodeflashCacheDir:
    def __init__(self):
        self._tempdir = tempfile.TemporaryDirectory()
        self._path = Path(self._tempdir.name)

    def __truediv__(self, other):
        return self._path / other

    def cleanup(self):
        self._tempdir.cleanup()

# Patch codeflash_cache_dir for testing
codeflash_cache_dir = DummyCodeflashCacheDir()

patches_dir = codeflash_cache_dir / "patches"

# Helper function to initialize a git repo with a file
def init_git_repo_with_commit(repo_dir: Path) -> str:
    repo = git.Repo.init(str(repo_dir))
    file = repo_dir / "README.md"
    file.write_text("Initial commit\n")
    repo.index.add([str(file)])
    commit = repo.index.commit("init commit")
    return commit.hexsha
from codeflash.code_utils.git_utils import get_patches_metadata

# --- End: Setup for testing environment ---

# --- Begin: Unit Tests ---

@pytest.fixture(scope="function")
def temp_git_repo(monkeypatch):
    """
    Fixture to create a temporary git repo and patch search_parent_directories to point to it.
    """
    orig_cwd = os.getcwd()
    tempdir = tempfile.TemporaryDirectory()
    repo_dir = Path(tempdir.name)
    os.chdir(repo_dir)
    commit_sha = init_git_repo_with_commit(repo_dir)

    # Patch codeflash_cache_dir to use our tempdir
    monkeypatch.setattr("codeflash.code_utils.compat.codeflash_cache_dir", codeflash_cache_dir)
    # Patch patches_dir to use our tempdir
    global patches_dir
    patches_dir = codeflash_cache_dir / "patches"

    yield repo_dir, commit_sha

    os.chdir(orig_cwd)
    tempdir.cleanup()
    codeflash_cache_dir.cleanup()

# --- Basic Test Cases ---

def test_metadata_file_exists_and_is_valid(temp_git_repo):
    """
    Basic: If metadata.json exists and is valid, it should be loaded and returned.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = {"id": commit_sha, "patches": [{"name": "patch1"}, {"name": "patch2"}]}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.9μs -> 17.8μs (45.5% faster)

def test_metadata_file_missing_returns_default(temp_git_repo):
    """
    Basic: If metadata.json is missing, should return default structure.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    if project_patches_dir.exists():
        shutil.rmtree(project_patches_dir)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 19.9μs -> 12.1μs (64.8% faster)

def test_metadata_file_empty_list(temp_git_repo):
    """
    Basic: metadata.json with empty patches list.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = {"id": commit_sha, "patches": []}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.1μs -> 17.5μs (48.9% faster)

def test_metadata_file_with_extra_fields(temp_git_repo):
    """
    Basic: metadata.json with extra fields should be loaded as-is.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = {"id": commit_sha, "patches": [{"name": "patch1"}], "extra": "value"}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.8μs -> 17.7μs (46.1% faster)

# --- Edge Test Cases ---



def test_metadata_file_missing_id_field(temp_git_repo):
    """
    Edge: metadata.json missing 'id' field.
    Should return whatever is in the file, even if 'id' is missing.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = {"patches": [{"name": "patch1"}]}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.2μs -> 17.9μs (46.4% faster)

def test_metadata_file_missing_patches_field(temp_git_repo):
    """
    Edge: metadata.json missing 'patches' field.
    Should return whatever is in the file, even if 'patches' is missing.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = {"id": commit_sha}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.2μs -> 17.8μs (47.8% faster)

def test_metadata_file_is_not_a_dict(temp_git_repo):
    """
    Edge: metadata.json contains a list instead of a dict.
    Should return the loaded list.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta = [{"id": commit_sha, "patches": []}]
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.0μs -> 17.5μs (48.7% faster)

def test_metadata_file_is_null(temp_git_repo):
    """
    Edge: metadata.json contains 'null'.
    Should return None.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta_file.write_text("null")
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.4μs -> 17.3μs (47.3% faster)

def test_metadata_file_is_integer(temp_git_repo):
    """
    Edge: metadata.json contains an integer.
    Should return the integer.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta_file.write_text("12345")
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.7μs -> 17.4μs (47.6% faster)

def test_metadata_file_is_string(temp_git_repo):
    """
    Edge: metadata.json contains a string.
    Should return the string.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    meta_file.write_text(json.dumps("hello world"))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.5μs -> 17.5μs (46.2% faster)

# --- Large Scale Test Cases ---

def test_large_number_of_patches(temp_git_repo):
    """
    Large Scale: metadata.json contains a large number of patches.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    patches = [{"name": f"patch_{i}", "data": "x"*100} for i in range(1000)]
    meta = {"id": commit_sha, "patches": patches}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 28.6μs -> 19.6μs (45.6% faster)

def test_large_metadata_file_size(temp_git_repo):
    """
    Large Scale: metadata.json is very large (but < 1MB).
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    # Each patch is ~1KB, total ~500KB
    patches = [{"name": f"patch_{i}", "data": "x"*1000} for i in range(500)]
    meta = {"id": commit_sha, "patches": patches}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 30.0μs -> 21.6μs (39.0% faster)

def test_large_metadata_file_with_extra_fields(temp_git_repo):
    """
    Large Scale: metadata.json with 1000 patches and extra fields.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    patches = [{"name": f"patch_{i}", "data": "x"*10} for i in range(1000)]
    meta = {"id": commit_sha, "patches": patches, "extra_field": "extra_value"}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 28.3μs -> 19.5μs (45.2% faster)


def test_metadata_file_with_large_patch_objects(temp_git_repo):
    """
    Large Scale: metadata.json contains patches with large data fields.
    """
    repo_dir, commit_sha = temp_git_repo
    project_patches_dir = patches_dir / commit_sha
    project_patches_dir.mkdir(parents=True, exist_ok=True)
    meta_file = project_patches_dir / "metadata.json"
    # Each patch has a 10KB string
    patches = [{"name": f"patch_{i}", "data": "x"*10000} for i in range(10)]
    meta = {"id": commit_sha, "patches": patches}
    meta_file.write_text(json.dumps(meta))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 28.3μs -> 18.6μs (52.3% 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
import shutil
import tempfile
from functools import lru_cache
from pathlib import Path
from typing import Any
from unittest import mock

import git
# imports
import pytest  # used for our unit tests
from codeflash.code_utils.compat import codeflash_cache_dir
from codeflash.code_utils.git_utils import get_patches_metadata
from git import Repo

patches_dir = codeflash_cache_dir / "patches"
from codeflash.code_utils.git_utils import get_patches_metadata


# Helper to create metadata.json
def create_metadata_json(path: Path, content: dict):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(content))

# 1. Basic Test Cases

def test_metadata_file_exists_and_valid():
    """Test when metadata.json exists and contains valid data."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    expected = {"id": "FAKE_SHA", "patches": [{"patch_id": 1, "desc": "test"}]}
    create_metadata_json(meta_file, expected)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 27.3μs -> 19.1μs (42.6% faster)

def test_metadata_file_does_not_exist_returns_default():
    """Test when metadata.json does not exist, should return default structure."""
    # No file created
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.7μs -> 17.7μs (45.3% faster)

def test_metadata_file_exists_empty_patches():
    """Test when metadata.json exists with empty patches list."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    expected = {"id": "FAKE_SHA", "patches": []}
    create_metadata_json(meta_file, expected)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 27.2μs -> 18.7μs (46.0% faster)

def test_metadata_file_exists_extra_fields():
    """Test when metadata.json contains extra fields."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    expected = {"id": "FAKE_SHA", "patches": [], "extra": "value"}
    create_metadata_json(meta_file, expected)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 27.0μs -> 18.6μs (45.3% faster)

# 2. Edge Test Cases



def test_metadata_file_exists_not_dict(monkeypatch):
    """Test when metadata.json exists but contains a non-dict JSON (e.g., a list)."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    meta_file.parent.mkdir(parents=True, exist_ok=True)
    meta_file.write_text(json.dumps([{"patch_id": 1}]))
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.7μs -> 18.8μs (42.0% faster)

def test_metadata_file_exists_with_null(monkeypatch):
    """Test when metadata.json exists and contains null."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    meta_file.parent.mkdir(parents=True, exist_ok=True)
    meta_file.write_text("null")
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.5μs -> 18.9μs (40.1% faster)


def test_metadata_file_exists_with_large_patch_ids():
    """Test with very large patch IDs."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    large_patch = {"id": "FAKE_SHA", "patches": [{"patch_id": 2**63, "desc": "big"}]}
    create_metadata_json(meta_file, large_patch)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 27.1μs -> 19.3μs (40.4% faster)

def test_metadata_file_exists_with_empty_id():
    """Test when metadata.json exists with empty id."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    content = {"id": "", "patches": []}
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 25.7μs -> 18.6μs (38.6% faster)

def test_metadata_file_exists_with_patches_none():
    """Test when metadata.json exists with patches=None."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    content = {"id": "FAKE_SHA", "patches": None}
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.0μs -> 18.4μs (41.4% faster)

# 3. Large Scale Test Cases

def test_metadata_file_exists_many_patches():
    """Test with a large number of patches."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    patches = [{"patch_id": i, "desc": f"patch {i}"} for i in range(1000)]
    content = {"id": "FAKE_SHA", "patches": patches}
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 27.3μs -> 19.2μs (42.2% faster)

def test_metadata_file_exists_large_json_structure():
    """Test with a very large and nested metadata.json structure."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    content = {
        "id": "FAKE_SHA",
        "patches": [{"patch_id": i, "desc": f"patch {i}", "extra": {"nested": [j for j in range(10)]}} for i in range(500)],
        "extra_field": {"deep": {"deeper": [str(i) for i in range(100)]}}
    }
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 28.2μs -> 19.8μs (42.6% faster)

def test_metadata_file_exists_with_large_strings():
    """Test with very large strings in metadata.json."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    big_string = "x" * 10000
    content = {"id": "FAKE_SHA", "patches": [{"patch_id": 1, "desc": big_string}]}
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.9μs -> 19.2μs (40.2% faster)

def test_metadata_file_exists_with_many_fields():
    """Test with many fields in the metadata dict."""
    patches_dir = Path(codeflash_cache_dir) / "patches" / "FAKE_SHA"
    meta_file = patches_dir / "metadata.json"
    content = {"id": "FAKE_SHA", "patches": [], **{f"field_{i}": i for i in range(100)}}
    create_metadata_json(meta_file, content)
    codeflash_output = get_patches_metadata(); result = codeflash_output # 26.5μs -> 18.8μs (40.6% faster)
    for i in range(100):
        pass
# 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-pr690-2025-08-27T15.58.44 and push.

[mohammedahmed18]

would accept it, but I moved the worktree related code to a new worktree utils file
so I'll add the changes manually

update: I will fix the conflicts instead