remove ignored linting issues

[Saga4]

No description provided.

[codeflash-ai]

⚡️Codeflash found 101% (1.01x) speedup for determine_dependency_manager in codeflash/cli_cmds/cmd_init.py

⏱️ Runtime : 3.86 milliseconds → 1.91 milliseconds (best of 247 runs)

📝 Explanation and details

This optimization achieves a 101% speedup (2.02x faster) by replacing Python's pathlib.Path operations with lower-level os module functions for file system checks.

Key Changes

Replaced pathlib.Path with os module:

• Path.cwd() → os.getcwd() (12x faster: 17.0μs → 1.4μs per call)
• (cwd / "poetry.lock").exists() → os.path.exists(os.path.join(cwd, "poetry.lock")) (2.7x faster: 22.6μs → 8.3μs per call)
• (cwd / "uv.lock").exists() → os.path.exists(os.path.join(cwd, "uv.lock")) (2.9x faster: 20.4μs → 7.1μs per call)

Why This Is Faster

The line profiler shows 97% of execution time (20.2ms out of 20.8ms) was spent on just three lines:

1. Getting current working directory (27.7% of total time)
2. Checking poetry.lock existence (36.6% of total time)
3. Checking uv.lock existence (32.7% of total time)

pathlib.Path provides a high-level, object-oriented interface with operator overloading (/) and method chaining, which adds overhead:

• Each Path object creation involves class instantiation
• The / operator triggers __truediv__ magic method calls
• .exists() method has additional validation and type checking

In contrast, os module functions are thin wrappers around C-level system calls, avoiding Python object overhead entirely.

Impact on Real Workloads

Based on function_references, this function is called during GitHub Actions workflow generation in two hot paths:

1. generate_dynamic_workflow_content() - Called when initializing CI/CD workflows
2. customize_codeflash_yaml_content() - Called for workflow customization

Both functions execute dependency manager detection during repository setup. While setup is not a high-frequency operation, the 2x speedup improves developer experience during codeflash init runs.

Test Results Analysis

All test cases show 80-110% speedup, with particularly strong gains in:

• Lock file detection tests: 85-109% faster (tests that hit the early-return path benefit most)
• Large-scale tests (500 keys): 91% faster (showing the optimization scales well)
• Mixed configuration tests: 86-104% faster (common in real projects)

The optimization is most effective when lock files exist (enabling early returns), but still provides significant gains even when the full tool section must be analyzed.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

from enum import Enum

# imports
from codeflash.cli_cmds.cmd_init import determine_dependency_manager


# Provide the DependencyManager enum so the function under test can refer to it.
# In the real codebase this would live in the module being tested; for the purposes
# of this standalone test file we define it here with the exact members expected.
class DependencyManager(Enum):
    POETRY = "poetry"
    UV = "uv"
    PIP = "pip"
    UNKNOWN = "unknown"


def test_no_tool_key_defaults_to_pip(tmp_path, monkeypatch):
    # When pyproject.toml contains no "tool" section, the default is PIP.
    monkeypatch.chdir(tmp_path)  # ensure an empty cwd without lock files
    codeflash_output = determine_dependency_manager({})
    result = codeflash_output  # 36.5μs -> 19.7μs (85.2% faster)


def test_poetry_lock_file_takes_precedence_over_pyproject(tmp_path, monkeypatch):
    # If poetry.lock exists in cwd it should return POETRY regardless of pyproject contents.
    monkeypatch.chdir(tmp_path)
    # create poetry.lock file
    (tmp_path / "poetry.lock").write_text("")  # create an empty lock file
    # Even if pyproject indicates pip, the lock file should win
    pyproject = {"tool": {"pip": {}}}
    codeflash_output = determine_dependency_manager(pyproject)  # 21.9μs -> 10.4μs (109% faster)


def test_uv_lock_file_detected_when_no_poetry_lock(tmp_path, monkeypatch):
    # If uv.lock exists and poetry.lock does not, UV should be returned.
    monkeypatch.chdir(tmp_path)
    (tmp_path / "uv.lock").write_text("")  # create uv.lock
    codeflash_output = determine_dependency_manager({"tool": {}})  # 35.4μs -> 19.7μs (80.2% faster)


def test_poetry_key_in_tool_section_detected():
    # If "tool" contains a "poetry" key, detect POETRY.
    pyproject = {"tool": {"poetry": {"name": "example"}}}
    codeflash_output = determine_dependency_manager(pyproject)  # 33.9μs -> 17.8μs (90.9% faster)


def test_uv_key_in_tool_section_detected_before_pip():
    # Ensure UV is detected before PIP when both markers exist in tool section.
    pyproject = {"tool": {"pip": {}, "uv": {}}}
    # The function checks for poetry, then uv, then pip. Hence UV should be returned.
    codeflash_output = determine_dependency_manager(pyproject)  # 32.6μs -> 17.5μs (86.2% faster)


def test_uv_prefix_key_detected():
    # Keys that start with "uv" (e.g., "uv-core", "uvtool") should be detected as UV.
    pyproject = {"tool": {"uv-core": {}, "something": {}}}
    codeflash_output = determine_dependency_manager(pyproject)  # 32.3μs -> 17.3μs (86.7% faster)


def test_pip_detected_via_setuptools_key_too():
    # The presence of "setuptools" in tool should also map to PIP.
    pyproject = {"tool": {"setuptools": {"setup.cfg": {}}}}
    codeflash_output = determine_dependency_manager(pyproject)  # 32.0μs -> 17.1μs (87.3% faster)


def test_unknown_when_tool_present_but_no_markers():
    # If "tool" exists but doesn't contain poetry, uv*, pip, or setuptools, return UNKNOWN.
    pyproject = {"tool": {}}  # explicit empty tool section
    codeflash_output = determine_dependency_manager(pyproject)  # 32.0μs -> 16.9μs (89.4% faster)


def test_tool_value_as_string_poetry_behaviour():
    # If tool is a non-dict but contains the substring "poetry", the 'in' check will still
    # find it (since strings support membership checks). This is an edge case that follows
    # from the original implementation's use of 'in'.
    pyproject = {"tool": "poetry"}  # not typical but valid input shape to test behavior
    codeflash_output = determine_dependency_manager(pyproject)  # 31.7μs -> 17.0μs (86.6% faster)


def test_tool_value_as_string_uv_edge_case():
    # Another unusual shape: tool is a string that does not cause the uv detection to work
    # because the function iterates characters. This ensures we capture that behavior.
    pyproject = {"tool": "uvtool"}  # membership for poetry fails; any(...) will iterate chars
    # Expect UNKNOWN because 'poetry' not in "uvtool", the any(...) over characters won't startwith('uv'),
    # and neither 'pip' nor 'setuptools' are substrings that the function checks using 'in'.
    codeflash_output = determine_dependency_manager(pyproject)  # 31.8μs -> 17.1μs (85.7% faster)


def test_large_scale_many_keys_with_uv_at_end():
    # Large-scale style test: create many keys (but <1000) to ensure algorithm still finds uv
    # and does not time out or fail. We keep it deterministic and modest in size.
    many_keys = {f"key_{i}": {} for i in range(500)}  # 500 keys - within the requested limit
    many_keys["uv_final"] = {"config": True}  # add the uv-prefixed key at the end
    pyproject = {"tool": many_keys}
    codeflash_output = determine_dependency_manager(pyproject)  # 34.1μs -> 17.8μs (91.2% faster)


def test_ordering_poetry_over_uv_and_uv_over_pip(tmp_path, monkeypatch):
    # Create both lock files to ensure poetry.lock precedence over uv.lock
    monkeypatch.chdir(tmp_path)
    (tmp_path / "uv.lock").write_text("uv content")
    (tmp_path / "poetry.lock").write_text("poetry content")
    # poetry.lock checked first so expect POETRY
    codeflash_output = determine_dependency_manager({"tool": {"uv": {}, "pip": {}}})  # 22.5μs -> 11.0μs (104% faster)


def test_uv_detection_with_nonstandard_keys():
    # Ensure keys like 'uv123', 'uv-' still count as starting with 'uv'
    pyproject = {"tool": {"uv123": {}, "notuv": {}, "pip": {}}}
    codeflash_output = determine_dependency_manager(pyproject)  # 33.6μs -> 18.0μs (87.4% 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 tempfile
from pathlib import Path

import pytest

from codeflash.cli_cmds.cmd_init import determine_dependency_manager


def test_poetry_lock_file_exists():
    """Test that poetry.lock file presence returns DependencyManager.POETRY."""
    with tempfile.TemporaryDirectory() as tmpdir:
        # Create a poetry.lock file in the temporary directory
        poetry_lock_path = Path(tmpdir) / "poetry.lock"
        poetry_lock_path.touch()

        # Change to the temporary directory
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            codeflash_output = determine_dependency_manager({})
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_uv_lock_file_exists():
    """Test that uv.lock file presence returns DependencyManager.UV."""
    with tempfile.TemporaryDirectory() as tmpdir:
        # Create a uv.lock file in the temporary directory
        uv_lock_path = Path(tmpdir) / "uv.lock"
        uv_lock_path.touch()

        # Change to the temporary directory
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            codeflash_output = determine_dependency_manager({})
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_poetry_in_tool_section():
    """Test that poetry in tool section returns DependencyManager.POETRY."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"poetry": {"name": "my-project", "version": "0.1.0"}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_uv_in_tool_section():
    """Test that uv tool config returns DependencyManager.UV."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"uv": {"project": {"requires-python": ">=3.8"}}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_pip_in_tool_section():
    """Test that pip in tool section returns DependencyManager.PIP."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"pip": {"index-url": "https://pypi.org/simple"}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_setuptools_in_tool_section():
    """Test that setuptools in tool section returns DependencyManager.PIP."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"setuptools": {"packages": ["my_package"]}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_no_tool_section_returns_pip():
    """Test that missing tool section defaults to DependencyManager.PIP."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"build-system": {"requires": ["setuptools"]}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_empty_pyproject_returns_pip():
    """Test that empty pyproject.toml data defaults to DependencyManager.PIP."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            codeflash_output = determine_dependency_manager({})
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_poetry_lock_takes_precedence_over_pyproject():
    """Test that poetry.lock file takes precedence over pyproject.toml tool section."""
    with tempfile.TemporaryDirectory() as tmpdir:
        # Create poetry.lock file
        poetry_lock_path = Path(tmpdir) / "poetry.lock"
        poetry_lock_path.touch()

        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Even with uv in tool section, poetry.lock should take precedence
            pyproject_data = {"tool": {"uv": {}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_uv_lock_takes_precedence_over_pyproject():
    """Test that uv.lock file takes precedence over pyproject.toml tool section."""
    with tempfile.TemporaryDirectory() as tmpdir:
        # Create uv.lock file
        uv_lock_path = Path(tmpdir) / "uv.lock"
        uv_lock_path.touch()

        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Even with poetry in tool section, uv.lock should take precedence
            pyproject_data = {"tool": {"poetry": {}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_poetry_lock_takes_precedence_over_uv_lock():
    """Test that poetry.lock is checked before uv.lock."""
    with tempfile.TemporaryDirectory() as tmpdir:
        # Create both lock files
        poetry_lock_path = Path(tmpdir) / "poetry.lock"
        poetry_lock_path.touch()
        uv_lock_path = Path(tmpdir) / "uv.lock"
        uv_lock_path.touch()

        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            codeflash_output = determine_dependency_manager({})
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_tool_section_exists_but_empty():
    """Test that empty tool section returns DependencyManager.UNKNOWN."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_unknown_tool_in_tool_section():
    """Test that unknown tool in tool section returns DependencyManager.UNKNOWN."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"black": {"line-length": 88}, "isort": {"profile": "black"}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_uv_tool_with_prefix_matching():
    """Test that tools starting with 'uv' are recognized."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Test with 'uv-config' which starts with 'uv'
            pyproject_data = {"tool": {"uv-config": {"some-setting": "value"}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_mixed_tools_poetry_takes_precedence():
    """Test that poetry takes precedence when both poetry and other tools are present."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"poetry": {"name": "project"}, "black": {"line-length": 88}, "setuptools": {}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_mixed_tools_uv_over_pip():
    """Test that uv takes precedence over pip when both are present."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"uv": {}, "pip": {}, "setuptools": {}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_tool_section_with_none_value():
    """Test handling of tool section with None value."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": None}
            # This should raise an error or be handled gracefully
            # The function iterates over tool_section keys, which would fail with None
            with pytest.raises((TypeError, AttributeError)):
                determine_dependency_manager(pyproject_data)
        finally:
            os.chdir(original_cwd)


def test_case_sensitive_tool_names():
    """Test that tool names are case-sensitive."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # 'Poetry' with capital P should not match 'poetry'
            pyproject_data = {"tool": {"Poetry": {"name": "project"}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_uv_as_substring_check():
    """Test that 'uv' prefix check works correctly."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Tool name starting with 'uv' should be recognized
            pyproject_data = {"tool": {"uvicorn": {}}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_nonexistent_directory_handling():
    """Test behavior when checking for lock files in nonexistent directory."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            # Create a path and immediately delete it
            test_path = Path(tmpdir) / "subdir"
            test_path.mkdir()
            os.chdir(test_path)
            test_path.rmdir()

            # This will try to check for lock files in a deleted directory
            # The Path.exists() should handle this gracefully
            with pytest.raises(FileNotFoundError):
                os.chdir(test_path)
        finally:
            os.chdir(original_cwd)


def test_large_tool_section_with_many_tools():
    """Test performance with a large number of tools in tool section."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Create a tool section with many tools
            tool_data = {f"tool_{i}": {"setting": "value"} for i in range(100)}
            tool_data["poetry"] = {"name": "project"}

            pyproject_data = {"tool": tool_data}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_large_pyproject_with_many_sections():
    """Test performance with a large pyproject.toml data structure."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Create a large pyproject.toml data structure
            pyproject_data = {
                "build-system": {"requires": ["poetry-core"]},
                "project": {"name": "my-project", "dependencies": [f"dep_{i}" for i in range(100)]},
                "tool": {f"tool_{i}": {"config": "value"} for i in range(50)},
            }
            pyproject_data["tool"]["uv"] = {}

            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_deep_nested_pyproject_structure():
    """Test with deeply nested pyproject.toml structure."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Create a deeply nested structure
            pyproject_data = {
                "tool": {"poetry": {"group": {"dev": {"dependencies": {"pytest": "^7.0", "black": "^22.0"}}}}}
            }
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_multiple_uv_prefixed_tools():
    """Test recognition of multiple tools starting with 'uv' prefix."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Multiple tools with 'uv' prefix
            pyproject_data = {"tool": {f"uv_tool_{i}": {"config": "value"} for i in range(50)}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_large_tool_data_with_many_keys():
    """Test with large amount of data in tool configurations."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Create a large tool configuration
            setuptools_config = {f"package_{i}": f"config_{i}" for i in range(200)}
            pyproject_data = {"tool": {"setuptools": setuptools_config}}
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_mixed_large_structure_poetry_takes_precedence():
    """Test with large mixed structure where poetry should win."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Create a large structure with many tools
            pyproject_data = {
                "project": {"dependencies": [f"dep_{i}" for i in range(50)]},
                "tool": {
                    "black": {f"setting_{i}": "value" for i in range(20)},
                    "isort": {f"setting_{i}": "value" for i in range(20)},
                    "pytest": {f"setting_{i}": "value" for i in range(20)},
                    "poetry": {"name": "project", "version": "0.1.0"},
                    "setuptools": {f"setting_{i}": "value" for i in range(20)},
                },
            }
            codeflash_output = determine_dependency_manager(pyproject_data)
            result = codeflash_output
        finally:
            os.chdir(original_cwd)


def test_performance_with_many_iterations():
    """Test that the function performs consistently across multiple calls."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            pyproject_data = {"tool": {"uv": {}}}

            # Call the function multiple times and verify consistent results
            results = [determine_dependency_manager(pyproject_data) for _ in range(100)]
        finally:
            os.chdir(original_cwd)


def test_stress_test_many_lock_files_check():
    """Test performance when checking for lock files that don't exist."""
    with tempfile.TemporaryDirectory() as tmpdir:
        original_cwd = Path.cwd()
        try:
            os.chdir(tmpdir)
            # Call the function many times with no lock files
            for _ in range(200):
                codeflash_output = determine_dependency_manager({})
                result = codeflash_output
        finally:
            os.chdir(original_cwd)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To test or edit this optimization locally git merge codeflash/optimize-pr1195-2026-01-29T17.28.26

Suggested change

	cwd = Path.cwd()
	if (cwd / "poetry.lock").exists():
	return DependencyManager.POETRY
	if (Path.cwd() / "uv.lock").exists():
	if (cwd / "uv.lock").exists():
	cwd = os.getcwd()
	if os.path.exists(os.path.join(cwd, "poetry.lock")):
	return DependencyManager.POETRY
	if os.path.exists(os.path.join(cwd, "uv.lock")):