⚡️ Speed up method RelativePathValidator.validate by 55% in PR #980 (inquirer)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #980

If you approve this dependent PR, these changes will be merged into the original PR branch inquirer.

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

---

📄 55% (0.55x) speedup for RelativePathValidator.validate in codeflash/cli_cmds/validators.py

⏱️ Runtime : 3.22 milliseconds → 2.08 milliseconds (best of 59 runs)

📝 Explanation and details

The optimization achieves a 54% speedup by restructuring the path validation logic to minimize expensive Path() object creation and method calls.

Key Optimization:
The original code called Path(path) twice - once for .is_absolute() check and again in the try-except block for validation. The optimized version creates the Path object only once and reuses it for both operations.

Specific Changes:

• Single Path object creation: Instead of Path(path).is_absolute() followed by a separate Path(path) in try-except, the code now creates one Path object (p = Path(path)) and calls p.is_absolute() on it
• Early Windows character validation: On Windows, invalid character checking is moved before Path creation, allowing early exit for invalid paths without the expensive Path construction
• Consolidated control flow: The absolute path check is moved inside the try-except blocks, reducing redundant Path operations

Performance Impact:
The line profiler shows the optimization eliminates one expensive Path(path) call per validation. In the original code, lines with Path(path) operations consumed ~84% of total runtime (45.1% + 39.2%). The optimized version reduces this to ~69.6% by eliminating the duplicate Path creation.

Test Results Analysis:

• Valid paths: 16-70% faster (most common case benefits significantly)
• Invalid Windows characters: 243% faster due to early exit before Path creation
• Path traversal attempts: Minimal change since early string-based detection
• Large-scale tests: 63-70% faster, showing the optimization scales well

This optimization is particularly effective for validation-heavy workloads where the same paths are validated repeatedly, as the reduced object creation overhead compounds across multiple calls.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os

# Patch RelativePathValidator to use DummyValidationResult for testing
# imports
import pytest

from codeflash.cli_cmds.validators import RelativePathValidator


# Mocks for ValidationResult, Validator (since these are from textual.validation)
# We want to avoid external dependencies, so we provide simple stand-ins.
class DummyValidationResult:
    def __init__(self, is_valid, failure_description=""):
        self.is_valid = is_valid
        self.failure_description = failure_description

    def __eq__(self, other):
        return (
            isinstance(other, DummyValidationResult)
            and self.is_valid == other.is_valid
            and self.failure_description == other.failure_description
        )


class DummyValidator:
    def __init__(self, failure_description=None):
        self._failure_description = failure_description or "Must be a valid relative directory path"

    def failure(self, msg=None):
        return DummyValidationResult(False, msg or self._failure_description)

    def success(self):
        return DummyValidationResult(True, "")


RelativePathValidator.failure = DummyValidator.failure
RelativePathValidator.success = DummyValidator.success

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


def test_valid_simple_relative_path():
    """Should accept a simple relative path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src")
    result = codeflash_output  # 8.56μs -> 7.19μs (18.9% faster)


def test_valid_nested_relative_path():
    """Should accept a nested relative path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/app/module")
    result = codeflash_output  # 10.7μs -> 8.09μs (32.7% faster)


def test_valid_relative_path_with_trailing_slash():
    """Should accept a relative path with a trailing slash."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/app/")
    result = codeflash_output  # 9.84μs -> 7.30μs (34.7% faster)


def test_empty_string():
    """Should fail on empty string."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("")
    result = codeflash_output  # 932ns -> 981ns (4.99% slower)


def test_spaces_only():
    """Should fail on string with only spaces."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("    ")
    result = codeflash_output  # 1.38μs -> 1.40μs (1.50% slower)


def test_path_with_leading_and_trailing_spaces():
    """Should trim spaces and succeed if path is otherwise valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("  src/app  ")
    result = codeflash_output  # 10.1μs -> 7.72μs (30.7% faster)


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


def test_absolute_path_unix():
    """Should fail on absolute path (Unix)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("/usr/local/bin")
    result = codeflash_output  # 8.53μs -> 9.15μs (6.80% slower)


def test_absolute_path_windows():
    """Should fail on absolute path (Windows)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("C:\\Users\\me\\project")
    result = codeflash_output  # 8.55μs -> 6.68μs (27.9% faster)


def test_path_traversal_double_dot():
    """Should fail on path traversal '..' anywhere in the path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/../app")
    result = codeflash_output  # 1.75μs -> 1.75μs (0.000% faster)


def test_path_traversal_double_dot_windows():
    """Should fail on path traversal '..' with backslashes."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src\\..\\app")
    result = codeflash_output  # 1.85μs -> 1.93μs (4.14% slower)


def test_path_with_null_char_unix():
    """Should fail on Unix with null char."""
    if os.name != "nt":
        validator = RelativePathValidator()
        codeflash_output = validator.validate("src\0app")
        result = codeflash_output  # 7.43μs -> 2.09μs (255% faster)
    else:
        pytest.skip("Unix-only test")


def test_path_with_dot():
    """Should accept '.' as a valid relative path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate(".")
    result = codeflash_output  # 7.59μs -> 6.51μs (16.6% faster)


def test_path_with_dot_slash():
    """Should accept './src' as a valid relative path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("./src")
    result = codeflash_output  # 8.90μs -> 7.25μs (22.6% faster)


def test_path_with_only_slash():
    """Should fail on path that is only a slash."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("/")
    result = codeflash_output  # 6.49μs -> 6.76μs (4.01% slower)


def test_path_with_backslash_only():
    """Should fail on path that is only a backslash."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("\\")
    result = codeflash_output  # 8.35μs -> 6.23μs (33.9% faster)


def test_path_with_invalid_format():
    """Should fail on path with invalid format (e.g. too long, or invalid unicode)."""
    validator = RelativePathValidator()
    # Overly long path
    long_path = "a" * 5000
    codeflash_output = validator.validate(long_path)
    result = codeflash_output  # 13.9μs -> 12.1μs (15.0% faster)


def test_path_with_unicode_characters():
    """Should accept unicode characters in path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/模块")
    result = codeflash_output  # 11.7μs -> 8.34μs (40.4% faster)


def test_path_with_dotdot_at_start():
    """Should fail on '..' at the start."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("..")
    result = codeflash_output  # 1.68μs -> 1.60μs (4.99% faster)


def test_path_with_dotdot_at_end():
    """Should fail on '..' at the end."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/..")
    result = codeflash_output  # 1.61μs -> 1.65μs (2.42% slower)


def test_path_with_dotdot_in_middle():
    """Should fail on '..' in the middle."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/../app")
    result = codeflash_output  # 1.61μs -> 1.61μs (0.000% faster)


def test_path_with_multiple_separators():
    """Should accept path with multiple consecutive separators."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src///app")
    result = codeflash_output  # 9.87μs -> 7.38μs (33.6% faster)


def test_path_with_leading_separator():
    """Should fail if path starts with a separator (absolute path)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("/src/app")
    result = codeflash_output  # 8.16μs -> 8.47μs (3.56% slower)


def test_path_with_trailing_separator():
    """Should accept path with trailing separator."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/app/")
    result = codeflash_output  # 10.0μs -> 7.32μs (36.9% faster)


def test_path_with_mixed_separators():
    """Should accept path with mixed / and \\ on all platforms."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src\\app/module")
    result = codeflash_output  # 10.8μs -> 7.88μs (37.3% faster)


def test_path_with_double_slash_at_start():
    """Should fail if path starts with double slash (absolute path on Unix)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("//src/app")
    result = codeflash_output  # 7.92μs -> 8.49μs (6.71% slower)


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


def test_large_number_of_valid_paths():
    """Should accept a large number of valid relative paths."""
    validator = RelativePathValidator()
    for i in range(100):
        path = f"dir_{i}/subdir_{i}"
        codeflash_output = validator.validate(path)
        result = codeflash_output  # 453μs -> 278μs (63.1% faster)


def test_large_number_of_invalid_paths():
    """Should fail a large number of invalid paths with '..'."""
    validator = RelativePathValidator()
    for i in range(100):
        path = f"dir_{i}/../subdir_{i}"
        codeflash_output = validator.validate(path)
        result = codeflash_output  # 51.3μs -> 51.7μs (0.791% slower)


def test_long_relative_path():
    """Should accept a very long but valid relative path."""
    validator = RelativePathValidator()
    path = "/".join(f"dir{i}" for i in range(200))
    codeflash_output = validator.validate(path)
    result = codeflash_output  # 91.7μs -> 61.2μs (49.9% faster)


def test_long_relative_path_with_invalid_component():
    """Should fail if any component is invalid, even in a long path."""
    validator = RelativePathValidator()
    path = "/".join(f"dir{i}" for i in range(100)) + "/.."
    codeflash_output = validator.validate(path)
    result = codeflash_output  # 2.20μs -> 2.29μs (3.92% slower)


def test_performance_many_validations():
    """Should not degrade performance with many validations."""
    validator = RelativePathValidator()
    for i in range(500):
        path = f"dir_{i}/subdir_{i}"
        codeflash_output = validator.validate(path)
        result = codeflash_output  # 2.17ms -> 1.27ms (70.6% faster)


def test_performance_many_invalidations():
    """Should not degrade performance with many invalidations."""
    validator = RelativePathValidator()
    for i in range(500):
        path = f"..{i}/dir"
        codeflash_output = validator.validate(path)
        result = codeflash_output  # 248μs -> 250μs (1.09% slower)


# ---- Mutation-sensitive test: Ensure error message is correct ----


def test_error_message_for_dotdot():
    """Should provide a helpful error message for '..'."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("foo/../bar")
    result = codeflash_output  # 1.68μs -> 1.77μs (5.08% slower)


def test_error_message_for_absolute():
    """Should provide a helpful error message for absolute path."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("/foo/bar")
    result = codeflash_output  # 8.71μs -> 9.34μs (6.75% slower)


def test_error_message_for_invalid_chars():
    """Should provide a helpful error message for invalid characters."""
    validator = RelativePathValidator()
    if os.name == "nt":
        codeflash_output = validator.validate("foo<bar")
        result = codeflash_output  # 6.87μs -> 2.00μs (243% faster)
    else:
        codeflash_output = validator.validate("foo\0bar")
        result = codeflash_output


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

import os

# imports
import pytest

# Patch Validator.success and Validator.failure to return DummyValidationResult for test assertions
from codeflash.cli_cmds.validators import RelativePathValidator


# Dummy ValidationResult for assertion (since textual.validation.ValidationResult is not imported)
class DummyValidationResult:
    def __init__(self, is_valid, message):
        self.is_valid = is_valid
        self.message = message

    def __eq__(self, other):
        return (
            hasattr(other, "is_valid")
            and hasattr(other, "message")
            and self.is_valid == other.is_valid
            and self.message == other.message
        )


# =======================
# BASIC TEST CASES
# =======================


def test_valid_simple_relative_path():
    """A simple relative path should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src")
    result = codeflash_output
    assert_valid(result)


def test_valid_nested_relative_path():
    """A nested relative path should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/app/tests")
    result = codeflash_output
    assert_valid(result)


def test_valid_relative_path_with_dot():
    """A path with single dot should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("./src")
    result = codeflash_output
    assert_valid(result)


def test_valid_relative_path_with_trailing_slash():
    """A path with trailing slash should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/")
    result = codeflash_output
    assert_valid(result)


def test_valid_relative_path_with_spaces_inside():
    """A path with spaces inside should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("my folder/with space")
    result = codeflash_output
    assert_valid(result)


# =======================
# EDGE TEST CASES
# =======================


def test_empty_string():
    """Empty string should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("")
    result = codeflash_output
    assert_invalid(result, "empty")


def test_whitespace_only():
    """Whitespace-only string should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("   ")
    result = codeflash_output
    assert_invalid(result, "empty")


def test_dotdot_in_path():
    """Path traversal attempt using '..' should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src/../secrets")
    result = codeflash_output
    assert_invalid(result, "..")


def test_dotdot_at_start():
    """Path starting with '..' should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("../src")
    result = codeflash_output
    assert_invalid(result, "..")


def test_dotdot_with_backslash():
    """Path traversal with backslash should be invalid (Windows style)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("..\\src")
    result = codeflash_output
    assert_invalid(result, "..")


def test_absolute_path_unix():
    """Absolute path (Unix style) should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("/etc/passwd")
    result = codeflash_output
    assert_invalid(result, "absolute")


def test_absolute_path_windows():
    """Absolute path (Windows style) should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("C:\\Users\\me")
    result = codeflash_output
    assert_invalid(result, "absolute")


def test_path_with_null_byte():
    """Path containing null byte should be invalid (Unix)."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("src\0app")
    result = codeflash_output
    assert_invalid(result, "invalid characters")


@pytest.mark.skipif(os.name != "nt", reason="Only relevant on Windows")
@pytest.mark.parametrize("char", ["<", ">", ":", '"', "|", "?", "*"])
def test_path_with_windows_invalid_chars(char):
    """Path containing invalid Windows characters should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate(f"foo{char}bar")
    result = codeflash_output
    assert_invalid(result, "invalid characters")


def test_path_with_only_dot():
    """A path that is just '.' should be valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate(".")
    result = codeflash_output
    assert_valid(result)


def test_path_with_only_double_dot():
    """A path that is just '..' should be invalid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("..")
    result = codeflash_output
    assert_invalid(result, "..")


def test_path_with_leading_and_trailing_spaces():
    """A path with leading/trailing spaces should be trimmed and valid."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("  src/app  ")
    result = codeflash_output
    assert_valid(result)


def test_path_with_newline_and_tab():
    """A path with newlines/tabs should be trimmed and valid if otherwise fine."""
    validator = RelativePathValidator()
    codeflash_output = validator.validate("\nsrc/app\t")
    result = codeflash_output
    assert_valid(result)


def test_path_with_invalid_format():
    """A path with invalid format (e.g., invalid unicode) should be invalid."""
    validator = RelativePathValidator()
    # This is hard to trigger, but try a path with a surrogate (invalid in UTF-8)
    bad_path = "src/\udc80"
    validator = RelativePathValidator()
    try:
        codeflash_output = validator.validate(bad_path)
        result = codeflash_output
    except Exception:
        pytest.fail("validate should not raise exceptions for invalid unicode")


# =======================
# LARGE SCALE TEST CASES
# =======================


def test_long_deep_relative_path():
    """A long but valid relative path should be valid."""
    validator = RelativePathValidator()
    path = "/".join([f"dir{i}" for i in range(100)])
    codeflash_output = validator.validate(path)
    result = codeflash_output
    assert_valid(result)


def test_long_path_with_dotdot_in_middle():
    """A long path with '..' somewhere should be invalid."""
    validator = RelativePathValidator()
    parts = [f"dir{i}" for i in range(50)] + [".."] + [f"dir{i}" for i in range(50, 100)]
    path = "/".join(parts)
    codeflash_output = validator.validate(path)
    result = codeflash_output
    assert_invalid(result, "..")


def test_many_valid_paths():
    """Test validator on many valid paths in a loop."""
    validator = RelativePathValidator()
    for i in range(100):
        path = f"project/subdir{i}/module"
        codeflash_output = validator.validate(path)
        result = codeflash_output
        assert_valid(result)


def test_many_invalid_paths():
    """Test validator on many invalid paths in a loop."""
    validator = RelativePathValidator()
    for i in range(100):
        path = f"../bad{i}/dir"
        codeflash_output = validator.validate(path)
        result = codeflash_output
        assert_invalid(result, "..")


def test_path_with_max_length():
    """A path near the typical max length (255 chars) should be valid if otherwise fine."""
    validator = RelativePathValidator()
    path = "a" * 250
    codeflash_output = validator.validate(path)
    result = codeflash_output
    assert_valid(result)


def test_path_exceeding_max_length():
    """A path exceeding typical max length should still be valid (no explicit length check)."""
    validator = RelativePathValidator()
    path = "a" * 300
    codeflash_output = validator.validate(path)
    result = codeflash_output
    assert_valid(result)


# 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-pr980-2025-12-22T11.01.45 and push.