⚡️ Speed up function _apply_deterministic_patches by 138% in PR #864 (non-round-time)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #864

If you approve this dependent PR, these changes will be merged into the original PR branch non-round-time.

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

---

📄 138% (1.38x) speedup for _apply_deterministic_patches in codeflash/verification/pytest_plugin.py

⏱️ Runtime : 1.13 milliseconds → 476 microseconds (best of 11 runs)

📝 Explanation and details

Optimizations applied:

• Construct fixed_datetime without tzinfo in the constructor, then .replace() for speed (avoids datetime validation logic).
• Use uuid.UUID(bytes=bytes.fromhex(...)) instead of parsing hyphenated string for faster UUID creation.
• Skip slow np.random.default_rng(42) and only seed legacy RNG, which is all that is required and is much faster for this purpose.
• Avoid default_rng creation overhead, which was a major bottleneck.
• All behavioral preservation rules, comments, and naming remain fully intact.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import builtins
import datetime
import random
import time
import uuid

# imports
import pytest  # used for our unit tests
from codeflash.verification.pytest_plugin import _apply_deterministic_patches


# Helper functions for datetime patching (since we can't monkeypatch classmethods)
def patched_datetime_now(tz=None):
    return builtins._mock_datetime_now(tz)

def patched_datetime_utcnow():
    return builtins._mock_datetime_utcnow()

# ---- UNIT TESTS ----

# BASIC TEST CASES

def test_time_time_basic():
    """Basic: After patch, time.time returns fixed value."""
    _apply_deterministic_patches() # 59.0μs -> 25.0μs (136% faster)

def test_perf_counter_basic_increment():
    """Basic: perf_counter increments by 0.001 per call, starting from fixed value."""
    _apply_deterministic_patches() # 55.3μs -> 23.6μs (134% faster)
    start = time.perf_counter()
    second = time.perf_counter()
    third = time.perf_counter()

def test_uuid4_and_uuid1_basic():
    """Basic: uuid4 and uuid1 always return the same fixed UUID."""
    _apply_deterministic_patches() # 56.3μs -> 23.2μs (143% faster)
    expected = uuid.UUID("12345678-1234-5678-9abc-123456789012")

def test_random_basic():
    """Basic: random.random returns fixed float."""
    _apply_deterministic_patches() # 55.2μs -> 23.0μs (140% faster)
    val = random.random()

def test_datetime_now_basic():
    """Basic: patched datetime.now returns fixed datetime."""
    _apply_deterministic_patches() # 55.0μs -> 23.1μs (138% faster)
    dt = patched_datetime_now()
    expected = datetime.datetime(2021, 1, 1, 2, 5, 10, tzinfo=datetime.timezone.utc)


def test_datetime_utcnow_basic():
    """Basic: patched datetime.utcnow returns fixed datetime."""
    _apply_deterministic_patches() # 54.5μs -> 22.2μs (145% faster)
    dt = patched_datetime_utcnow()
    expected = datetime.datetime(2021, 1, 1, 2, 5, 10, tzinfo=datetime.timezone.utc)

# EDGE TEST CASES

def test_perf_counter_many_calls():
    """Edge: perf_counter increments correctly over many calls (1000)."""
    _apply_deterministic_patches() # 54.9μs -> 22.9μs (140% faster)
    vals = [time.perf_counter() for _ in range(1000)]
    for i in range(1, len(vals)):
        pass

def test_uuid1_arguments_edge():
    """Edge: uuid1 with various arguments always returns fixed UUID."""
    _apply_deterministic_patches() # 58.5μs -> 23.9μs (145% faster)
    expected = uuid.UUID("12345678-1234-5678-9abc-123456789012")

def test_random_seed_effect():
    """Edge: random.seed should not affect random.random after patch."""
    _apply_deterministic_patches() # 56.0μs -> 23.8μs (135% faster)
    random.seed(999)
    random.seed(0)

def test_datetime_now_edge_tz():
    """Edge: datetime.now with None and UTC tzinfo returns correct tz."""
    _apply_deterministic_patches() # 55.3μs -> 22.9μs (142% faster)
    dt_none = patched_datetime_now()
    dt_utc = patched_datetime_now(datetime.timezone.utc)


def test_datetime_now_patch_isolated():
    """Edge: patched datetime.now does not affect original datetime.datetime.now."""
    _apply_deterministic_patches() # 66.3μs -> 29.5μs (124% faster)
    # The builtins patch should not affect the actual datetime.datetime.now method
    now_actual = datetime.datetime.now()
    patched = patched_datetime_now()

# LARGE SCALE TEST CASES

def test_perf_counter_large_scale():
    """Large: perf_counter works for 1000+ calls, increments correctly."""
    _apply_deterministic_patches() # 57.5μs -> 24.2μs (137% faster)
    vals = [time.perf_counter() for _ in range(1000)]

def test_random_large_scale():
    """Large: random.random returns fixed value for many calls."""
    _apply_deterministic_patches() # 60.3μs -> 27.6μs (119% faster)
    vals = [random.random() for _ in range(1000)]
    for v in vals:
        pass

def test_uuid4_large_scale():
    """Large: uuid4 returns fixed UUID for many calls."""
    _apply_deterministic_patches() # 58.0μs -> 25.0μs (132% faster)
    expected = uuid.UUID("12345678-1234-5678-9abc-123456789012")
    vals = [uuid.uuid4() for _ in range(1000)]
    for v in vals:
        pass



#------------------------------------------------
from __future__ import annotations

import datetime
import random
import sys
import time
import uuid

# imports
import pytest  # used for our unit tests
from codeflash.verification.pytest_plugin import _apply_deterministic_patches

# --------- BASIC TEST CASES ---------

def test_time_time_is_deterministic():
    """Basic: time.time() always returns the fixed timestamp."""
    val1 = time.time()
    val2 = time.time()

def test_perf_counter_increments():
    """Basic: time.perf_counter() increments by 0.001 per call."""
    base = 1761717605.108106
    v1 = time.perf_counter()
    v2 = time.perf_counter()
    v3 = time.perf_counter()

def test_uuid4_is_fixed():
    """Basic: uuid.uuid4() always returns the fixed UUID."""
    val = uuid.uuid4()

def test_uuid1_is_fixed():
    """Basic: uuid.uuid1() always returns the fixed UUID, regardless of args."""
    val1 = uuid.uuid1()
    val2 = uuid.uuid1(node=0x123456789abc, clock_seq=12345)

def test_random_random_is_fixed():
    """Basic: random.random() always returns the fixed float."""
    val1 = random.random()
    val2 = random.random()

def test_random_seed_consistency():
    """Basic: random.seed() is set, so random.randint is deterministic."""
    random.seed(42)
    val1 = random.randint(1, 100)
    random.seed(42)
    val2 = random.randint(1, 100)




def test_perf_counter_many_calls():
    """Edge: perf_counter increments correctly over many calls."""
    base = 1761717605.108106
    for i in range(1, 101):
        pass

def test_uuid1_with_various_args():
    """Edge: uuid.uuid1() ignores node and clock_seq, always fixed."""
    for node in [None, 0, 123456789012345, 2**48-1]:
        for clock_seq in [None, 0, 16383]:
            val = uuid.uuid1(node=node, clock_seq=clock_seq)

def test_random_random_edge_values():
    """Edge: random.random() always returns fixed value even after reseed."""
    random.seed(999)
    random.seed(-1)




def test_random_randint_consistency():
    """Edge: random.randint produces deterministic output after seed."""
    random.seed(1234)
    val1 = random.randint(1, 100)
    random.seed(1234)
    val2 = random.randint(1, 100)

def test_random_uniform_consistency():
    """Edge: random.uniform produces deterministic output after seed."""
    random.seed(5678)
    val1 = random.uniform(0, 1)
    random.seed(5678)
    val2 = random.uniform(0, 1)

# --------- LARGE SCALE TEST CASES ---------

def test_perf_counter_large_scale():
    """Large Scale: perf_counter increments correctly over 1000 calls."""
    base = 1761717605.108106
    for i in range(101, 1001):
        pass


def test_random_randint_large(monkeypatch):
    """Large Scale: random.randint produces deterministic sequence for 1000 calls."""
    random.seed(42)
    vals = [random.randint(0, 1000000) for _ in range(1000)]
    random.seed(42)
    vals2 = [random.randint(0, 1000000) for _ in range(1000)]

def test_random_random_large(monkeypatch):
    """Large Scale: random.random() is always fixed for 1000 calls."""
    vals = [random.random() for _ in range(1000)]

def test_uuid4_large_scale():
    """Large Scale: uuid.uuid4() returns fixed UUID for 1000 calls."""
    vals = [str(uuid.uuid4()) for _ in range(1000)]

def test_uuid1_large_scale():
    """Large Scale: uuid.uuid1() returns fixed UUID for 1000 calls."""
    vals = [str(uuid.uuid1()) for _ in range(1000)]



#------------------------------------------------
from codeflash.verification.pytest_plugin import _apply_deterministic_patches

def test__apply_deterministic_patches():
    _apply_deterministic_patches()

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_4bkkdwcj/tmp25aa7i15/test_concolic_coverage.py::test__apply_deterministic_patches	136μs	59.0μs	132%✅

To edit these changes git checkout codeflash/optimize-pr864-2025-10-29T06.11.59 and push.