⚡️ Speed up function calculate_video_file_stride by 33%

[codeflash-ai]

📄 33% (0.33x) speedup for calculate_video_file_stride in inference/core/interfaces/camera/video_source.py

⏱️ Runtime : 588 microseconds → 442 microseconds (best of 262 runs)

📝 Explanation and details

The optimized code achieves a 33% speedup through several key micro-optimizations:

1. Consolidated conditional checks: Combined the four separate if statements checking for None and negative values into a single compound condition using or. This reduces branching overhead and enables faster early exit when invalid inputs are detected.

2. Eliminated unnecessary max() calls:

• Replaced max(int(true_stride), 1) with direct conditional logic (if int_stride < 1: int_stride = 1)
• Removed max(true_stride - integer_stride, 0) since the subtraction can never be negative when integer_stride = int(true_stride)

3. Optimized random number generation: Added a miss_prob > 0 check before calling random.random(). This avoids expensive RNG calls in common cases where the probability is exactly 0 (when actual_fps / desired_fps is a whole number), which happens frequently with typical video frame rates.

4. Reduced function call overhead: Direct assignment of int(true_stride) instead of wrapping it in max() eliminates one function call per execution.

The optimizations are particularly effective for test cases involving:

• Equal frame rates (60-158% faster) where miss_prob = 0
• Integer stride ratios (50-80% faster) where random calls are avoided
• Edge cases with invalid inputs (up to 17% faster) due to consolidated checks

These changes maintain identical behavior while reducing computational overhead in the hot path of video frame processing.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import random
from typing import Optional, Union

# imports
import pytest  # used for our unit tests
from inference.core.interfaces.camera.video_source import \
    calculate_video_file_stride

# unit tests

# Basic Test Cases

def test_stride_equal_fps(monkeypatch):
    # When actual_fps == desired_fps, stride should be 1
    codeflash_output = calculate_video_file_stride(30, 30) # 2.40μs -> 930ns (158% faster)
    codeflash_output = calculate_video_file_stride(24, 24) # 811ns -> 426ns (90.4% faster)

def test_stride_actual_greater_than_desired(monkeypatch):
    # When actual_fps > desired_fps, stride should be actual_fps // desired_fps
    # For 60/30 = 2.0, stride should be 2
    codeflash_output = calculate_video_file_stride(60, 30) # 1.96μs -> 807ns (143% faster)
    # For 50/25 = 2.0, stride should be 2
    codeflash_output = calculate_video_file_stride(50, 25) # 780ns -> 428ns (82.2% faster)

def test_stride_actual_less_than_desired(monkeypatch):
    # When actual_fps < desired_fps, stride should be 1
    codeflash_output = calculate_video_file_stride(15, 30) # 1.98μs -> 840ns (136% faster)
    codeflash_output = calculate_video_file_stride(10, 20) # 776ns -> 430ns (80.5% faster)

def test_stride_non_integer_result(monkeypatch):
    # When actual_fps / desired_fps is not integer, stride can be 1 or 2 depending on random
    # For 25/12 = 2.083..., stride should be 2 or 3
    monkeypatch.setattr(random, "random", lambda: 0.0)  # always below probability, so stride stays at int(true_stride)
    codeflash_output = calculate_video_file_stride(25, 12) # 1.45μs -> 1.15μs (26.7% faster)
    monkeypatch.setattr(random, "random", lambda: 0.083)  # just above probability, so stride increases
    codeflash_output = calculate_video_file_stride(25, 12) # 690ns -> 605ns (14.0% faster)

def test_stride_rounding(monkeypatch):
    # For 29.97/10 = 2.997, stride should be 2 or 3
    monkeypatch.setattr(random, "random", lambda: 0.5)  # below probability, so stride increases
    codeflash_output = calculate_video_file_stride(29.97, 10) # 1.44μs -> 1.14μs (26.0% faster)
    monkeypatch.setattr(random, "random", lambda: 0.0)  # above probability, so stride stays
    codeflash_output = calculate_video_file_stride(29.97, 10) # 713ns -> 540ns (32.0% faster)

# Edge Test Cases

def test_none_inputs():
    # If either input is None, stride should be 1
    codeflash_output = calculate_video_file_stride(None, 30) # 280ns -> 276ns (1.45% faster)
    codeflash_output = calculate_video_file_stride(30, None) # 239ns -> 221ns (8.14% faster)
    codeflash_output = calculate_video_file_stride(None, None) # 149ns -> 127ns (17.3% faster)

def test_negative_inputs():
    # Negative FPS values should return stride 1
    codeflash_output = calculate_video_file_stride(-30, 30) # 408ns -> 364ns (12.1% faster)
    codeflash_output = calculate_video_file_stride(30, -30) # 308ns -> 302ns (1.99% faster)
    codeflash_output = calculate_video_file_stride(-30, -30) # 163ns -> 151ns (7.95% faster)

def test_zero_inputs():
    # Zero FPS values should return stride 1 (since division by zero is not allowed)
    codeflash_output = calculate_video_file_stride(0, 30)
    codeflash_output = calculate_video_file_stride(30, 0)
    codeflash_output = calculate_video_file_stride(0, 0)

def test_float_inputs(monkeypatch):
    # Check with float values
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(29.97, 29.97) # 1.87μs -> 1.22μs (52.8% faster)
    codeflash_output = calculate_video_file_stride(29.97, 15) # 975ns -> 970ns (0.515% faster)
    monkeypatch.setattr(random, "random", lambda: 0.999)
    codeflash_output = calculate_video_file_stride(29.97, 15) # 549ns -> 487ns (12.7% faster)

def test_stride_minimum_value(monkeypatch):
    # Stride should never be less than 1
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(1, 100) # 1.51μs -> 946ns (59.5% faster)
    codeflash_output = calculate_video_file_stride(0.1, 100) # 755ns -> 493ns (53.1% faster)

def test_stride_large_probability(monkeypatch):
    # If probability_of_missing_frame > 0, stride may increase
    monkeypatch.setattr(random, "random", lambda: 0.99)
    codeflash_output = calculate_video_file_stride(25, 12) # 1.34μs -> 1.04μs (28.5% faster)

def test_stride_probability_zero(monkeypatch):
    # If probability_of_missing_frame == 0, stride should not increase
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(30, 30) # 1.23μs -> 751ns (63.5% faster)

# Large Scale Test Cases

def test_large_fps(monkeypatch):
    # Test with large FPS values
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(1000, 250) # 1.30μs -> 843ns (53.9% faster)
    codeflash_output = calculate_video_file_stride(999, 250) # 769ns -> 679ns (13.3% faster)
    monkeypatch.setattr(random, "random", lambda: 0.997)
    codeflash_output = calculate_video_file_stride(999, 250) # 517ns -> 398ns (29.9% faster)

def test_many_calls_deterministic(monkeypatch):
    # Test many calls with fixed random to ensure determinism
    monkeypatch.setattr(random, "random", lambda: 0.0)
    for i in range(1, 1000, 100):
        codeflash_output = calculate_video_file_stride(i, i) # 5.06μs -> 2.90μs (74.6% faster)
        codeflash_output = calculate_video_file_stride(i*2, i)
        codeflash_output = calculate_video_file_stride(i*3, i) # 4.29μs -> 2.44μs (75.6% faster)

def test_performance_large_scale(monkeypatch):
    # Test performance with large scale inputs, but not exceeding 1000 elements
    monkeypatch.setattr(random, "random", lambda: 0.0)
    for actual_fps in range(1, 1001, 100):
        for desired_fps in range(1, 1001, 100):
            codeflash_output = calculate_video_file_stride(actual_fps, desired_fps); stride = codeflash_output

def test_large_scale_random(monkeypatch):
    # Test random behavior for non-integer stride
    stride_counts = {2: 0, 3: 0}
    # For actual_fps=25, desired_fps=12, true_stride=2.083..., probability=0.083
    # Simulate 1000 calls with random.random() cycling between 0.0 and 0.1
    random_values = [0.0, 0.1] * 500
    def random_side_effect():
        return random_values.pop(0)
    monkeypatch.setattr(random, "random", random_side_effect)
    for _ in range(1000):
        codeflash_output = calculate_video_file_stride(25, 12); stride = codeflash_output # 466μs -> 362μs (28.7% faster)
        stride_counts[stride] += 1
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import random

# imports
import pytest  # used for our unit tests
from inference.core.interfaces.camera.video_source import \
    calculate_video_file_stride

# unit tests

# --- Basic Test Cases ---

def test_stride_equal_fps(monkeypatch):
    # actual_fps == desired_fps -> stride should be 1
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(30, 30) # 1.57μs -> 937ns (68.0% faster)
    codeflash_output = calculate_video_file_stride(24.0, 24.0) # 889ns -> 634ns (40.2% faster)

def test_stride_higher_actual(monkeypatch):
    # actual_fps > desired_fps, e.g. 60/30 = 2
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(60, 30) # 1.25μs -> 799ns (55.9% faster)
    # 90/30 = 3
    codeflash_output = calculate_video_file_stride(90, 30) # 679ns -> 419ns (62.1% faster)

def test_stride_lower_actual(monkeypatch):
    # actual_fps < desired_fps, e.g. 15/30 = 0.5, stride must be at least 1
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(15, 30) # 1.41μs -> 784ns (79.7% faster)
    # 10/60 = 0.166..., stride must be at least 1
    codeflash_output = calculate_video_file_stride(10, 60) # 702ns -> 446ns (57.4% faster)

def test_stride_fractional(monkeypatch):
    # actual_fps = 25, desired_fps = 12, 25/12 ≈ 2.0833
    # int(2.0833) = 2, probability_of_missing_frame = 0.0833
    # If random.random() < 0.0833, stride = 3, else stride = 2
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(25, 12) # 1.39μs -> 1.11μs (24.4% faster)
    monkeypatch.setattr(random, "random", lambda: 0.1)
    codeflash_output = calculate_video_file_stride(25, 12) # 723ns -> 583ns (24.0% faster)
    monkeypatch.setattr(random, "random", lambda: 0.08)
    codeflash_output = calculate_video_file_stride(25, 12) # 548ns -> 373ns (46.9% faster)

# --- Edge Test Cases ---

def test_none_inputs():
    # Any None input returns 1
    codeflash_output = calculate_video_file_stride(None, 30) # 321ns -> 280ns (14.6% faster)
    codeflash_output = calculate_video_file_stride(30, None) # 255ns -> 248ns (2.82% faster)
    codeflash_output = calculate_video_file_stride(None, None) # 146ns -> 138ns (5.80% faster)

def test_negative_inputs():
    # Any negative input returns 1
    codeflash_output = calculate_video_file_stride(-30, 30) # 382ns -> 352ns (8.52% faster)
    codeflash_output = calculate_video_file_stride(30, -30) # 305ns -> 296ns (3.04% faster)
    codeflash_output = calculate_video_file_stride(-1, -1) # 168ns -> 163ns (3.07% faster)

def test_zero_desired(monkeypatch):
    # actual_fps > 0, desired_fps = 0, division by zero
    # Should raise ZeroDivisionError
    monkeypatch.setattr(random, "random", lambda: 0.0)
    with pytest.raises(ZeroDivisionError):
        calculate_video_file_stride(30, 0) # 1.06μs -> 1.04μs (1.73% faster)

def test_zero_actual(monkeypatch):
    # actual_fps = 0, desired_fps > 0, stride should be 0
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(0, 30) # 1.76μs -> 1.06μs (66.7% faster)

def test_stride_just_below_integer(monkeypatch):
    # actual_fps = 59.9, desired_fps = 30, 59.9/30 ≈ 1.9967
    # int(1.9967) = 1, probability = 0.9967
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(59.9, 30) # 1.64μs -> 1.29μs (26.6% faster)
    monkeypatch.setattr(random, "random", lambda: 0.995)
    codeflash_output = calculate_video_file_stride(59.9, 30) # 795ns -> 583ns (36.4% faster)
    monkeypatch.setattr(random, "random", lambda: 0.997)
    codeflash_output = calculate_video_file_stride(59.9, 30) # 579ns -> 431ns (34.3% faster)

def test_stride_just_above_integer(monkeypatch):
    # actual_fps = 61, desired_fps = 30, 61/30 ≈ 2.0333
    # int(2.0333) = 2, probability = 0.0333
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(61, 30) # 1.37μs -> 1.10μs (24.3% faster)
    monkeypatch.setattr(random, "random", lambda: 0.04)
    codeflash_output = calculate_video_file_stride(61, 30) # 774ns -> 603ns (28.4% faster)
    monkeypatch.setattr(random, "random", lambda: 0.03)
    codeflash_output = calculate_video_file_stride(61, 30) # 522ns -> 399ns (30.8% faster)

def test_stride_large_fraction(monkeypatch):
    # actual_fps = 100, desired_fps = 33, 100/33 ≈ 3.0303
    # int(3.0303) = 3, probability = 0.0303
    monkeypatch.setattr(random, "random", lambda: 0.02)
    codeflash_output = calculate_video_file_stride(100, 33) # 1.27μs -> 1.02μs (24.0% faster)
    monkeypatch.setattr(random, "random", lambda: 0.04)
    codeflash_output = calculate_video_file_stride(100, 33) # 711ns -> 581ns (22.4% faster)

def test_stride_minimum(monkeypatch):
    # actual_fps = 0.1, desired_fps = 1000, 0.1/1000 = 0.0001
    # int(0.0001) = 0, max(0,1) = 1
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(0.1, 1000) # 1.54μs -> 926ns (66.1% faster)

def test_stride_large_numbers(monkeypatch):
    # actual_fps = 1000, desired_fps = 1, 1000/1 = 1000
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(1000, 1) # 1.38μs -> 823ns (67.6% faster)

# --- Large Scale Test Cases ---

@pytest.mark.parametrize("actual,desired", [
    (1000, 1000),  # stride = 1
    (1000, 500),   # stride = 2
    (1000, 333),   # stride = 3
    (1000, 250),   # stride = 4
    (1000, 1),     # stride = 1000
])
def test_stride_large_scale(monkeypatch, actual, desired):
    # Test with large actual_fps and desired_fps
    monkeypatch.setattr(random, "random", lambda: 0.0)
    expected_stride = max(int(actual / desired), 1)
    codeflash_output = calculate_video_file_stride(actual, desired) # 5.96μs -> 4.25μs (40.2% faster)

def test_stride_large_fractional(monkeypatch):
    # actual_fps = 999, desired_fps = 333, 999/333 = 3.0
    # int(3.0) = 3, probability = 0
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(999, 333) # 1.39μs -> 889ns (56.8% faster)

def test_stride_large_many(monkeypatch):
    # Test many values in a loop for scalability, but under 1000 iterations
    monkeypatch.setattr(random, "random", lambda: 0.0)
    for i in range(1, 1000, 100):
        actual_fps = i * 10
        desired_fps = i
        expected_stride = max(int(actual_fps / desired_fps), 1)
        codeflash_output = calculate_video_file_stride(actual_fps, desired_fps) # 5.16μs -> 3.08μs (67.4% faster)

def test_stride_large_small_desired(monkeypatch):
    # actual_fps = 999, desired_fps = 1, stride = 999
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(999, 1) # 1.25μs -> 861ns (45.6% faster)

def test_stride_large_small_actual(monkeypatch):
    # actual_fps = 1, desired_fps = 999, stride = 1 (since must be at least 1)
    monkeypatch.setattr(random, "random", lambda: 0.0)
    codeflash_output = calculate_video_file_stride(1, 999) # 1.44μs -> 912ns (57.6% 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-calculate_video_file_stride-mhbqzkpv and push.