⚡️ Speed up function should_run_sync by 6%

[codeflash-ai]

📄 6% (0.06x) speedup for should_run_sync in guardrails/validator_service/__init__.py

⏱️ Runtime : 6.97 milliseconds → 6.58 milliseconds (best of 51 runs)

📝 Explanation and details

The optimized code achieves a 5% speedup through three key optimizations:

1. Early short-circuit for process_count == 1: After converting process_count to an integer, the code immediately returns True if it equals 1, avoiding the subsequent string operations and comparisons. This is particularly effective for test cases where GUARDRAILS_PROCESS_COUNT="1" is set, showing up to 59% speedup in the warning test case.

2. Eliminate redundant run_sync.lower() calls: The original code calls .lower() twice - once in the validation check and once in the final return statement. The optimized version stores run_sync_lower once and reuses it, reducing string processing overhead. This benefits all test cases that process the GUARDRAILS_RUN_SYNC environment variable.

3. Replace list with tuple for membership testing: Changed ["true", "false"] to ("true", "false") for the validation check. Tuple membership testing is slightly faster than list membership testing in Python due to simpler memory layout and immutability optimizations.

These optimizations are most effective for scenarios where GUARDRAILS_PROCESS_COUNT="1" (early return) or when GUARDRAILS_RUN_SYNC requires processing (avoiding duplicate .lower() calls). The improvements are consistent across all test cases, with particularly notable gains in edge cases involving warnings and validation logic.

✅ Correctness verification report:

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

⚙️ Existing Unit Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_guardrails_run_sync_is_false	2.84μs	2.41μs	17.9%✅
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_guardrails_run_sync_is_true	2.89μs	2.43μs	18.7%✅
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_process_count_is_1_and_guardrails_run_sync_is_false	8.28μs	7.71μs	7.42%✅
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_process_count_is_2	9.01μs	8.49μs	6.13%✅
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_process_count_is_2_and_guardrails_run_sync_is_true	8.85μs	8.41μs	5.19%✅
integration_tests/validator_service/test_init.py::TestShouldRunSync.test_process_count_is_one	8.40μs	7.67μs	9.42%✅
unit_tests/validator_service/test_validator_service.py::TestShouldRunSync.test_process_count_of_1	27.0μs	28.3μs	-4.40%⚠️
unit_tests/validator_service/test_validator_service.py::TestShouldRunSync.test_run_sync_set_to_true	27.8μs	29.4μs	-5.71%⚠️
unit_tests/validator_service/test_validator_service.py::TestShouldRunSync.test_should_run_sync_default	26.6μs	28.8μs	-7.54%⚠️

🌀 Generated Regression Tests and Runtime

import os
import warnings

# imports
import pytest  # used for our unit tests
from guardrails.validator_service.__init__ import should_run_sync

# unit tests

@pytest.mark.parametrize(
    "env,expected",
    [
        # BASIC CASES
        # 1. Neither env var set: should return False
        ({}, False),
        # 2. GUARDRAILS_RUN_SYNC true, no process count: should return True
        ({"GUARDRAILS_RUN_SYNC": "true"}, True),
        # 3. GUARDRAILS_RUN_SYNC false, no process count: should return False
        ({"GUARDRAILS_RUN_SYNC": "false"}, False),
        # 4. GUARDRAILS_RUN_SYNC TRUE (case insensitivity): should return True
        ({"GUARDRAILS_RUN_SYNC": "TRUE"}, True),
        # 5. GUARDRAILS_RUN_SYNC FALSE (case insensitivity): should return False
        ({"GUARDRAILS_RUN_SYNC": "FALSE"}, False),
        # 6. GUARDRAILS_PROCESS_COUNT=1, no run_sync: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1"}, True),
        # 7. GUARDRAILS_PROCESS_COUNT=2, no run_sync: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "2"}, False),
        # 8. GUARDRAILS_PROCESS_COUNT=1, run_sync=false: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "false"}, True),
        # 9. GUARDRAILS_PROCESS_COUNT=2, run_sync=true: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "2", "GUARDRAILS_RUN_SYNC": "true"}, True),
        # 10. GUARDRAILS_PROCESS_COUNT=2, run_sync=false: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "2", "GUARDRAILS_RUN_SYNC": "false"}, False),
        # 11. GUARDRAILS_PROCESS_COUNT=1, run_sync=true: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "true"}, True),
        # EDGE CASES
        # 12. GUARDRAILS_PROCESS_COUNT=0, run_sync=false: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "0", "GUARDRAILS_RUN_SYNC": "false"}, False),
        # 13. GUARDRAILS_PROCESS_COUNT=-1, run_sync=false: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "-1", "GUARDRAILS_RUN_SYNC": "false"}, False),
        # 14. GUARDRAILS_PROCESS_COUNT=1, run_sync=unexpected value: should return True (process_count wins)
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "yes"}, True),
        # 15. GUARDRAILS_PROCESS_COUNT=2, run_sync=unexpected value: should return False (run_sync defaults to false)
        ({"GUARDRAILS_PROCESS_COUNT": "2", "GUARDRAILS_RUN_SYNC": "yes"}, False),
        # 16. GUARDRAILS_RUN_SYNC=unexpected value, no process count: should return False (defaults to false)
        ({"GUARDRAILS_RUN_SYNC": "yes"}, False),
        # 17. GUARDRAILS_RUN_SYNC=empty string, no process count: should return False (defaults to false)
        ({"GUARDRAILS_RUN_SYNC": ""}, False),
        # 18. GUARDRAILS_RUN_SYNC=whitespace, no process count: should return False (defaults to false)
        ({"GUARDRAILS_RUN_SYNC": "   "}, False),
        # 19. GUARDRAILS_PROCESS_COUNT=non-integer string, run_sync=true: should raise ValueError
        # This will be tested separately below.
        # 20. GUARDRAILS_PROCESS_COUNT=None, GUARDRAILS_RUN_SYNC=None: should return False
        ({"GUARDRAILS_PROCESS_COUNT": None, "GUARDRAILS_RUN_SYNC": None}, False),
        # 21. GUARDRAILS_PROCESS_COUNT=1, GUARDRAILS_RUN_SYNC=None: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": None}, True),
        # 22. GUARDRAILS_PROCESS_COUNT=None, GUARDRAILS_RUN_SYNC="true": should return True
        ({"GUARDRAILS_PROCESS_COUNT": None, "GUARDRAILS_RUN_SYNC": "true"}, True),
        # 23. GUARDRAILS_PROCESS_COUNT=None, GUARDRAILS_RUN_SYNC="false": should return False
        ({"GUARDRAILS_PROCESS_COUNT": None, "GUARDRAILS_RUN_SYNC": "false"}, False),
        # LARGE SCALE CASES
        # 24. GUARDRAILS_PROCESS_COUNT=999, run_sync=false: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "999", "GUARDRAILS_RUN_SYNC": "false"}, False),
        # 25. GUARDRAILS_PROCESS_COUNT=1, run_sync=false: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "false"}, True),
        # 26. GUARDRAILS_PROCESS_COUNT=500, run_sync=true: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "500", "GUARDRAILS_RUN_SYNC": "true"}, True),
        # 27. GUARDRAILS_PROCESS_COUNT=500, run_sync=false: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "500", "GUARDRAILS_RUN_SYNC": "false"}, False),
        # 28. GUARDRAILS_PROCESS_COUNT=1, run_sync=unexpected value: should return True
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "unexpected"}, True),
        # 29. GUARDRAILS_PROCESS_COUNT=999, run_sync=unexpected value: should return False
        ({"GUARDRAILS_PROCESS_COUNT": "999", "GUARDRAILS_RUN_SYNC": "unexpected"}, False),
    ]
)
def test_should_run_sync_various(env, expected):
    """
    Test should_run_sync for a variety of basic, edge, and large scale scenarios.
    """
    # Save original environment
    orig_env = {k: os.environ.get(k) for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]}
    try:
        # Clear both vars
        for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]:
            if k in os.environ:
                del os.environ[k]
        # Set environment variables for this test case
        for k, v in env.items():
            if v is not None:
                os.environ[k] = v
        # Capture warnings to ensure they are triggered as expected
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter("always")
            codeflash_output = should_run_sync(); result = codeflash_output
            # Check warnings for deprecated GUARDRAILS_PROCESS_COUNT
            if env.get("GUARDRAILS_PROCESS_COUNT") is not None:
                pass
            # Check warnings for invalid GUARDRAILS_RUN_SYNC values
            run_sync_val = env.get("GUARDRAILS_RUN_SYNC")
            if run_sync_val is not None and run_sync_val.lower() not in ["true", "false"]:
                pass
    finally:
        # Restore original environment
        for k, v in orig_env.items():
            if v is not None:
                os.environ[k] = v
            elif k in os.environ:
                del os.environ[k]

def test_should_run_sync_invalid_process_count():
    """
    Test that should_run_sync raises ValueError for non-integer GUARDRAILS_PROCESS_COUNT.
    """
    orig_env = {k: os.environ.get(k) for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]}
    try:
        os.environ["GUARDRAILS_PROCESS_COUNT"] = "not_an_int"
        os.environ["GUARDRAILS_RUN_SYNC"] = "true"
        with pytest.raises(ValueError):
            should_run_sync()
    finally:
        # Restore original environment
        for k, v in orig_env.items():
            if v is not None:
                os.environ[k] = v
            elif k in os.environ:
                del os.environ[k]

def test_should_run_sync_large_scale():
    """
    Large scale: test with many different values for GUARDRAILS_PROCESS_COUNT.
    """
    orig_env = {k: os.environ.get(k) for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]}
    try:
        # Try values from 0 to 999
        for i in range(1000):
            os.environ["GUARDRAILS_PROCESS_COUNT"] = str(i)
            os.environ["GUARDRAILS_RUN_SYNC"] = "false"
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                codeflash_output = should_run_sync(); result = codeflash_output
                if i == 1:
                    pass
                else:
                    pass
    finally:
        # Restore original environment
        for k, v in orig_env.items():
            if v is not None:
                os.environ[k] = v
            elif k in os.environ:
                del os.environ[k]

def test_should_run_sync_large_scale_run_sync_true():
    """
    Large scale: test with GUARDRAILS_RUN_SYNC='true' and varying GUARDRAILS_PROCESS_COUNT.
    Should always return True.
    """
    orig_env = {k: os.environ.get(k) for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]}
    try:
        os.environ["GUARDRAILS_RUN_SYNC"] = "true"
        for i in range(1000):
            os.environ["GUARDRAILS_PROCESS_COUNT"] = str(i)
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                codeflash_output = should_run_sync(); result = codeflash_output
    finally:
        # Restore original environment
        for k, v in orig_env.items():
            if v is not None:
                os.environ[k] = v
            elif k in os.environ:
                del os.environ[k]

def test_should_run_sync_large_scale_run_sync_false():
    """
    Large scale: test with GUARDRAILS_RUN_SYNC='false' and varying GUARDRAILS_PROCESS_COUNT.
    Should only return True for process_count=1.
    """
    orig_env = {k: os.environ.get(k) for k in ["GUARDRAILS_PROCESS_COUNT", "GUARDRAILS_RUN_SYNC"]}
    try:
        os.environ["GUARDRAILS_RUN_SYNC"] = "false"
        for i in range(1000):
            os.environ["GUARDRAILS_PROCESS_COUNT"] = str(i)
            with warnings.catch_warnings(record=True) as w:
                warnings.simplefilter("always")
                codeflash_output = should_run_sync(); result = codeflash_output
                if i == 1:
                    pass
                else:
                    pass
    finally:
        # Restore original environment
        for k, v in orig_env.items():
            if v is not None:
                os.environ[k] = v
            elif k in os.environ:
                del os.environ[k]
# 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 warnings

# imports
import pytest
from guardrails.validator_service.__init__ import should_run_sync

# unit tests

@pytest.mark.parametrize(
    "env,expected",
    [
        # Basic: Neither env var set
        ({}, False),
        # Basic: GUARDRAILS_RUN_SYNC true
        ({"GUARDRAILS_RUN_SYNC": "true"}, True),
        # Basic: GUARDRAILS_RUN_SYNC false
        ({"GUARDRAILS_RUN_SYNC": "false"}, False),
        # Basic: GUARDRAILS_PROCESS_COUNT = "1"
        ({"GUARDRAILS_PROCESS_COUNT": "1"}, True),
        # Basic: GUARDRAILS_PROCESS_COUNT = "2"
        ({"GUARDRAILS_PROCESS_COUNT": "2"}, False),
        # Basic: Both set, RUN_SYNC true, PROCESS_COUNT 2
        ({"GUARDRAILS_RUN_SYNC": "true", "GUARDRAILS_PROCESS_COUNT": "2"}, True),
        # Basic: Both set, RUN_SYNC false, PROCESS_COUNT 1
        ({"GUARDRAILS_RUN_SYNC": "false", "GUARDRAILS_PROCESS_COUNT": "1"}, True),
        # Basic: Both set, RUN_SYNC false, PROCESS_COUNT 2
        ({"GUARDRAILS_RUN_SYNC": "false", "GUARDRAILS_PROCESS_COUNT": "2"}, False),
    ]
)
def test_should_run_sync_basic(monkeypatch, env, expected):
    """Test basic scenarios for should_run_sync."""
    # Clear environment
    monkeypatch.delenv("GUARDRAILS_RUN_SYNC", raising=False)
    monkeypatch.delenv("GUARDRAILS_PROCESS_COUNT", raising=False)
    # Set environment variables as needed
    for k, v in env.items():
        monkeypatch.setenv(k, v)
    # Check result
    codeflash_output = should_run_sync() # 51.1μs -> 47.8μs (6.95% faster)

@pytest.mark.parametrize(
    "env,expected",
    [
        # Edge: GUARDRAILS_RUN_SYNC = "TRUE" (case-insensitive)
        ({"GUARDRAILS_RUN_SYNC": "TRUE"}, True),
        # Edge: GUARDRAILS_RUN_SYNC = "False" (case-insensitive)
        ({"GUARDRAILS_RUN_SYNC": "False"}, False),
        # Edge: GUARDRAILS_RUN_SYNC = "TrUe" (mixed case)
        ({"GUARDRAILS_RUN_SYNC": "TrUe"}, True),
        # Edge: GUARDRAILS_RUN_SYNC = "yes" (invalid value, should warn, default to False)
        ({"GUARDRAILS_RUN_SYNC": "yes"}, False),
        # Edge: GUARDRAILS_RUN_SYNC = "" (empty string, invalid, should warn, default to False)
        ({"GUARDRAILS_RUN_SYNC": ""}, False),
        # Edge: GUARDRAILS_PROCESS_COUNT = "0" (should not trigger sync)
        ({"GUARDRAILS_PROCESS_COUNT": "0"}, False),
        # Edge: GUARDRAILS_PROCESS_COUNT = "-1" (should not trigger sync)
        ({"GUARDRAILS_PROCESS_COUNT": "-1"}, False),
        # Edge: GUARDRAILS_PROCESS_COUNT = "1", RUN_SYNC = "false" (should trigger sync due to process_count)
        ({"GUARDRAILS_PROCESS_COUNT": "1", "GUARDRAILS_RUN_SYNC": "false"}, True),
        # Edge: GUARDRAILS_PROCESS_COUNT = "not_an_int" (should raise ValueError)
        ({"GUARDRAILS_PROCESS_COUNT": "not_an_int"}, "ValueError"),
    ]
)
def test_should_run_sync_edge(monkeypatch, env, expected):
    """Test edge scenarios for should_run_sync."""
    monkeypatch.delenv("GUARDRAILS_RUN_SYNC", raising=False)
    monkeypatch.delenv("GUARDRAILS_PROCESS_COUNT", raising=False)
    for k, v in env.items():
        monkeypatch.setenv(k, v)
    # Special case for ValueError
    if expected == "ValueError":
        with pytest.raises(ValueError):
            should_run_sync() # 59.5μs -> 52.2μs (13.9% faster)
    else:
        codeflash_output = should_run_sync()

def test_should_run_sync_warns(monkeypatch):
    """Test that warnings are issued for deprecated and invalid values."""
    monkeypatch.setenv("GUARDRAILS_PROCESS_COUNT", "1")
    monkeypatch.setenv("GUARDRAILS_RUN_SYNC", "yes")
    # Should warn for deprecated PROCESS_COUNT and invalid RUN_SYNC value
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        codeflash_output = should_run_sync(); result = codeflash_output # 11.5μs -> 7.22μs (59.0% faster)

def test_should_run_sync_no_warn(monkeypatch):
    """Test that no warnings are issued for valid values."""
    monkeypatch.setenv("GUARDRAILS_RUN_SYNC", "true")
    monkeypatch.delenv("GUARDRAILS_PROCESS_COUNT", raising=False)
    with warnings.catch_warnings(record=True) as w:
        warnings.simplefilter("always")
        codeflash_output = should_run_sync(); result = codeflash_output # 3.05μs -> 2.65μs (15.2% faster)

@pytest.mark.parametrize(
    "count",
    [str(i) for i in range(1, 1001, 100)]  # Large scale: test 1, 101, ..., 901
)
def test_should_run_sync_large_scale(monkeypatch, count):
    """Test should_run_sync with many different process counts."""
    monkeypatch.setenv("GUARDRAILS_PROCESS_COUNT", count)
    monkeypatch.delenv("GUARDRAILS_RUN_SYNC", raising=False)
    # Only "1" should return True, others False
    expected = int(count) == 1
    if count.isdigit() or (count.startswith('-') and count[1:].isdigit()):
        # Should not raise error
        codeflash_output = should_run_sync() # 84.2μs -> 78.9μs (6.67% faster)
    else:
        # Should raise ValueError for non-integer
        with pytest.raises(ValueError):
            should_run_sync()

def test_should_run_sync_large_env(monkeypatch):
    """Test with many unrelated env vars to ensure function ignores them."""
    # Set 999 unrelated env vars
    for i in range(999):
        monkeypatch.setenv(f"UNRELATED_ENV_{i}", "value")
    # Set the real env var
    monkeypatch.setenv("GUARDRAILS_RUN_SYNC", "true")
    monkeypatch.delenv("GUARDRAILS_PROCESS_COUNT", raising=False)
    # Should still return True, unaffected by unrelated vars
    codeflash_output = should_run_sync() # 3.43μs -> 3.09μs (11.0% faster)

def test_should_run_sync_large_invalid(monkeypatch):
    """Test with large invalid GUARDRAILS_PROCESS_COUNT values."""
    monkeypatch.setenv("GUARDRAILS_PROCESS_COUNT", "1000")
    monkeypatch.delenv("GUARDRAILS_RUN_SYNC", raising=False)
    # Should not run sync for large process count
    codeflash_output = should_run_sync() # 9.20μs -> 8.55μs (7.59% faster)

def test_should_run_sync_empty_env(monkeypatch):
    """Test with all relevant env vars unset."""
    monkeypatch.delenv("GUARDRAILS_RUN_SYNC", raising=False)
    monkeypatch.delenv("GUARDRAILS_PROCESS_COUNT", raising=False)
    codeflash_output = should_run_sync() # 2.91μs -> 2.63μs (10.6% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

⏪ Replay Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
test_pytest_testsunit_teststest_guard_log_py_testsintegration_teststest_guard_py_testsunit_testsvalidator__replay_test_0.py::test_guardrails_validator_service___init___should_run_sync	149μs	141μs	5.96%✅

To edit these changes git checkout codeflash/optimize-should_run_sync-mh1r2geo and push.