⚡️ Speed up function command_exists by 16%

[codeflash-ai]

📄 16% (0.16x) speedup for command_exists in skyvern/cli/database.py

⏱️ Runtime : 11.0 milliseconds → 9.49 milliseconds (best of 216 runs)

📝 Explanation and details

The optimized code achieves a 16% speedup by inlining the core logic of shutil.which() and eliminating its overhead. Here's what was optimized:

Key Performance Improvements:

1. Eliminated shutil.which() overhead: The original code delegates entirely to shutil.which(), which has additional internal complexity for cross-platform compatibility and error handling that isn't needed here.

2. Efficient PATH processing: The optimized version splits the PATH environment variable only once and reuses the list, rather than potentially re-parsing it internally within shutil.which().

3. Early termination optimizations:

   • Fast path for empty PATH (returns immediately)
   • Quick detection of absolute/relative paths vs simple command names
   • Immediate return when executable is found

4. Reduced function call overhead: Direct OS operations (os.path.join, os.path.isfile, os.access) instead of going through shutil.which()'s abstraction layers.

Impact on Workloads:
Based on the function references, command_exists() is called in critical infrastructure setup paths:

• Docker detection: Called every time checking if Docker is available
• PostgreSQL setup: Called to verify psql and pg_isready availability
• Database initialization workflows: Multiple calls during setup sequences

The test results show particularly strong gains for edge cases like empty strings (102% faster) and custom PATH scenarios (53-172% faster), suggesting the optimization is especially effective when PATH is limited or commands don't exist.

Best Performance Cases:

• Commands that don't exist (18-20% faster on average)
• Empty or restricted PATH environments (100%+ faster)
• Batch processing of many commands (13-24% faster)
• Commands with absolute paths (15-17% faster)

This optimization is valuable since command_exists() is used in setup and validation workflows where it may be called repeatedly during system initialization.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import random
import shutil
import string

# imports
import pytest  # used for our unit tests
from skyvern.cli.database import command_exists

# unit tests

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

def test_existing_command_ls():
    # 'ls' is present on most Unix systems
    codeflash_output = command_exists('ls') # 20.1μs -> 16.6μs (21.5% faster)

def test_non_existing_command_gibberish():
    # A random string should not exist as a command
    codeflash_output = command_exists('thiscommanddoesnotexist123') # 23.0μs -> 19.5μs (18.0% faster)

def test_existing_command_echo():
    # 'echo' is a standard command on all platforms
    codeflash_output = command_exists('echo') # 18.3μs -> 14.8μs (23.5% faster)

def test_existing_command_with_path():
    # Should work for absolute path to an executable
    import sys
    python_path = sys.executable
    codeflash_output = command_exists(python_path) # 11.4μs -> 9.69μs (17.5% faster)

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

def test_empty_string():
    # Empty string should never be a valid command
    codeflash_output = command_exists('') # 38.2μs -> 18.9μs (102% faster)

def test_whitespace_string():
    # String with only whitespace should not be a valid command
    codeflash_output = command_exists('   ') # 23.5μs -> 19.7μs (19.3% faster)

def test_command_with_special_characters():
    # Commands with illegal characters should not exist
    codeflash_output = command_exists('ls$%^&*') # 22.7μs -> 19.2μs (17.9% faster)

def test_command_with_newline():
    # Command with newline should not exist
    codeflash_output = command_exists('ls\n') # 22.1μs -> 18.9μs (17.0% faster)

def test_command_with_path_traversal():
    # Path traversal should not resolve to a command
    codeflash_output = command_exists('../ls') # 7.03μs -> 6.97μs (0.847% faster)

def test_command_case_sensitivity():
    # On Unix, 'LS' is not the same as 'ls'
    codeflash_output = command_exists('LS') # 23.5μs -> 19.8μs (18.9% faster)

def test_command_with_leading_trailing_spaces():
    # Spaces around command should not resolve
    codeflash_output = command_exists('  ls  ') # 22.7μs -> 19.4μs (17.1% faster)

def test_command_with_extension():
    # On Windows, 'notepad.exe' should resolve, but 'notepad' also works due to PATHEXT
    import platform
    if platform.system() == 'Windows':
        codeflash_output = command_exists('notepad')
        codeflash_output = command_exists('notepad.exe')

def test_command_with_dot_slash():
    # './ls' should not resolve unless in current directory
    codeflash_output = command_exists('./ls') # 7.40μs -> 6.88μs (7.55% faster)

def test_command_in_subdirectory():
    # 'subdir/ls' should not resolve unless in PATH
    codeflash_output = command_exists('subdir/ls') # 6.64μs -> 6.57μs (1.10% faster)

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

def test_many_nonexistent_commands():
    # Test a large number of random commands that should not exist
    for _ in range(100):
        fake_cmd = ''.join(random.choices(string.ascii_letters + string.digits, k=16))
        codeflash_output = command_exists(fake_cmd) # 1.60ms -> 1.41ms (13.2% faster)

def test_many_existing_commands():
    # Test many common commands, most of which should exist on Unix
    common_cmds = [
        'ls', 'echo', 'cat', 'touch', 'mkdir', 'pwd', 'cp', 'mv', 'rm', 'chmod',
        'grep', 'find', 'head', 'tail', 'sort', 'date', 'whoami', 'uname', 'which',
        'sh', 'bash', 'python', 'python3'
    ]
    found = 0
    for cmd in common_cmds:
        if command_exists(cmd):
            found += 1

def test_long_command_name():
    # Very long command name should not exist
    long_name = 'a' * 256
    codeflash_output = command_exists(long_name) # 37.8μs -> 33.5μs (12.9% faster)

def test_batch_with_whitespace_and_special_characters():
    # Batch test commands with whitespace and special chars
    test_cmds = ['ls ', ' echo', 'cat\n', 'touch\t', 'mkdir!', '@pwd', '#cp']
    for cmd in test_cmds:
        codeflash_output = command_exists(cmd) # 120μs -> 104μs (15.5% faster)

def test_unicode_command_names():
    # Unicode command names should not resolve unless they exist
    unicode_cmds = ['λs', 'écho', '猫', 'питон', 'mkdir😊']
    for cmd in unicode_cmds:
        codeflash_output = command_exists(cmd) # 92.6μs -> 81.3μs (13.9% faster)

# ------------------------
# Determinism Test
# ------------------------

def test_determinism_with_same_input():
    # The function should always return the same result for the same input
    for cmd in ['ls', 'notarealcommand', 'python']:
        codeflash_output = command_exists(cmd); result1 = codeflash_output # 45.3μs -> 37.0μs (22.5% faster)
        codeflash_output = command_exists(cmd); result2 = codeflash_output # 32.8μs -> 26.7μs (22.7% faster)

# ------------------------
# Platform Specific Test Cases
# ------------------------

def test_windows_exe_extension():
    import platform
    if platform.system() == 'Windows':
        # On Windows, PATHEXT allows omitting .exe
        codeflash_output = command_exists('cmd')
        codeflash_output = command_exists('cmd.exe')

def test_unix_sh_and_bash():
    import platform
    if platform.system() != 'Windows':
        codeflash_output = command_exists('sh') # 19.6μs -> 15.9μs (23.6% faster)
        codeflash_output = command_exists('bash')

# ------------------------
# Path Environment Variable Test
# ------------------------

def test_command_not_in_path(monkeypatch):
    # Simulate a PATH with no commands, should always return False
    monkeypatch.setenv('PATH', '')
    codeflash_output = command_exists('ls') # 2.07μs -> 760ns (172% faster)
    codeflash_output = command_exists('python') # 872ns -> 328ns (166% faster)

def test_command_in_custom_path(tmp_path, monkeypatch):
    # Create a fake executable in a custom PATH and test detection
    fake_exe = tmp_path / "mycmd"
    fake_exe.write_text("#!/bin/sh\necho hi\n")
    fake_exe.chmod(0o755)
    monkeypatch.setenv('PATH', str(tmp_path))
    codeflash_output = command_exists('mycmd') # 10.5μs -> 6.84μs (53.2% faster)
    # Should not find it if not in PATH
    monkeypatch.setenv('PATH', '')
    codeflash_output = command_exists('mycmd') # 1.33μs -> 629ns (111% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

import random
import shutil
import string

# imports
import pytest  # used for our unit tests
from skyvern.cli.database import command_exists

# unit tests

# --- Basic Test Cases ---

def test_existing_command_ls():
    # Test with a common command that should exist on Unix systems
    codeflash_output = command_exists('ls') # 20.8μs -> 16.3μs (27.8% faster)

def test_existing_command_python():
    # Test with 'python', which may exist as 'python' or 'python3'
    codeflash_output = command_exists('python'); result = codeflash_output # 12.2μs -> 9.01μs (36.0% faster)
    expected = shutil.which('python') is not None

def test_non_existing_command():
    # Test with a command that is very unlikely to exist
    codeflash_output = command_exists('definitely_not_a_real_command_12345') # 24.7μs -> 20.9μs (18.0% faster)

def test_existing_command_echo():
    # Test with another common command
    codeflash_output = command_exists('echo') # 19.2μs -> 15.4μs (24.9% faster)

def test_existing_command_with_path():
    # Test with absolute path to an existing command
    ls_path = shutil.which('ls')
    if ls_path:
        codeflash_output = command_exists(ls_path) # 5.91μs -> 5.11μs (15.6% faster)
    else:
        pytest.skip("ls not found on this system")

def test_non_existing_command_with_path():
    # Test with an absolute path to a non-existent command
    codeflash_output = command_exists('/usr/bin/definitely_not_a_real_command_12345') # 6.54μs -> 6.04μs (8.21% faster)

# --- Edge Test Cases ---

def test_empty_string_command():
    # Empty string should not be a valid command
    codeflash_output = command_exists('') # 39.3μs -> 19.5μs (102% faster)

def test_whitespace_command():
    # Whitespace-only string should not be a valid command
    codeflash_output = command_exists('   ') # 24.2μs -> 20.2μs (19.8% faster)

def test_command_with_special_characters():
    # Command with special characters that are unlikely to exist
    codeflash_output = command_exists('!@#$%^&*()') # 22.8μs -> 19.5μs (17.0% faster)

def test_command_with_unicode():
    # Command with Unicode characters that are unlikely to exist
    codeflash_output = command_exists('命令不存在') # 24.1μs -> 20.6μs (17.1% faster)

def test_command_with_newline():
    # Command with newline character
    codeflash_output = command_exists('ls\n') # 22.7μs -> 18.9μs (20.5% faster)

def test_command_with_tab():
    # Command with tab character
    codeflash_output = command_exists('ls\t') # 21.8μs -> 18.8μs (15.9% faster)

def test_command_case_sensitivity():
    # Some systems are case sensitive, 'LS' may not exist
    codeflash_output = command_exists('LS') # 22.6μs -> 19.2μs (18.0% faster)

def test_command_with_leading_trailing_spaces():
    # Command with spaces around it should not be found
    codeflash_output = command_exists('  ls  ') # 22.2μs -> 18.6μs (19.1% faster)

def test_command_with_dot_slash():
    # Command with './' prefix (relative path); likely not found unless in cwd
    codeflash_output = command_exists('./ls') # 7.00μs -> 6.36μs (9.92% faster)

def test_command_with_double_slash():
    # Command with double slash, which is not a valid command name
    codeflash_output = command_exists('//ls') # 6.26μs -> 5.72μs (9.35% faster)

def test_command_with_env_variable():
    # Command with $PATH variable in name, which is not expanded by which
    codeflash_output = command_exists('$PATH') # 23.2μs -> 19.5μs (18.8% faster)

def test_command_with_long_name():
    # Command with a long random name (unlikely to exist)
    long_name = ''.join(random.choices(string.ascii_letters + string.digits, k=100))
    codeflash_output = command_exists(long_name) # 24.5μs -> 20.6μs (19.0% faster)

def test_command_with_slash_in_name():
    # Command with slash in name (not a valid command unless it's a path)
    codeflash_output = command_exists('ls/echo') # 6.59μs -> 6.14μs (7.32% faster)

def test_many_non_existing_commands():
    # Test with a large number of random names that should not exist
    for _ in range(100):
        name = ''.join(random.choices(string.ascii_lowercase, k=20))
        codeflash_output = command_exists(name) # 1.60ms -> 1.42ms (13.2% faster)

def test_many_existing_commands():
    # Test with a list of common commands (some may not exist on all systems)
    common_cmds = ['ls', 'echo', 'cat', 'grep', 'pwd', 'cd', 'touch', 'mkdir', 'rm', 'cp', 'mv', 'chmod', 'chown', 'head', 'tail', 'date', 'whoami', 'uname', 'which', 'python', 'python3']
    for cmd in common_cmds:
        # Only assert True if command is actually present on the system
        codeflash_output = command_exists(cmd) # 238μs -> 192μs (24.1% faster)

def test_large_input_string():
    # Test with a very large string as command name (unlikely to exist)
    big_command = 'a' * 1000
    codeflash_output = command_exists(big_command) # 35.9μs -> 32.5μs (10.2% faster)

def test_large_batch_mixed_commands():
    # Test with a mix of valid and invalid commands in a batch
    valid_cmds = ['ls', 'echo', 'pwd', 'python']
    invalid_cmds = ['notarealcmd1', 'notarealcmd2', 'notarealcmd3', 'notarealcmd4']
    batch = valid_cmds + invalid_cmds
    for cmd in batch:
        codeflash_output = command_exists(cmd) # 112μs -> 93.3μs (20.2% faster)

def test_performance_many_calls():
    # Test performance by calling the function many times (should not hang)
    for i in range(500):
        # Alternate between a likely valid and invalid command
        cmd = 'ls' if i % 2 == 0 else f'notrealcmd_{i}'
        expected = shutil.which(cmd) is not None
        codeflash_output = command_exists(cmd) # 6.46ms -> 5.53ms (16.7% faster)
# 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-command_exists-mir38qt3 and push.