⚡️ Speed up function _get_total_scope_state by 36%

[codeflash-ai]

📄 36% (0.36x) speedup for _get_total_scope_state in src/uberjob/progress/_html_progress_observer.py

⏱️ Runtime : 1.28 milliseconds → 943 microseconds (best of 250 runs)

📝 Explanation and details

The optimization replaces five separate sum() generator expressions with a single loop that accumulates all values in one pass. This eliminates the overhead of creating and iterating through generator objects multiple times.

Key changes:

• Single iteration: Instead of iterating through scope_states five times (once per field), the optimized version iterates only once
• Direct accumulation: Uses simple addition operators (+=) instead of the sum() builtin with generator expressions
• Reduced function call overhead: Eliminates five calls to sum() and the associated generator creation

Why it's faster:
In Python, generator expressions and the sum() function have overhead. The original code creates five separate generators and calls sum() five times, each requiring a complete iteration through scope_states. The optimized version performs attribute access and addition operations directly in a single loop, which is more efficient for the Python interpreter.

Impact based on usage:
The function is called from _render_section() when displaying progress totals across multiple scopes in HTML reports. Given that this is likely called during progress monitoring (potentially frequently), the 36% speedup reduces UI rendering latency.

Test case performance:
The optimization shows consistent improvements across all test scenarios:

• Small datasets (2-5 scope states): 49-73% faster
• Large datasets (1000 scope states): 22-40% faster
• Edge cases (zeros, negatives, large numbers): 38-57% faster

The performance gains are most pronounced with smaller datasets, which aligns with reducing the fixed overhead of multiple function calls and generator creation.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from collections import namedtuple

# imports
import pytest  # used for our unit tests
from uberjob.progress._html_progress_observer import _get_total_scope_state

# function to test

# Simulate ScopeState as in uberjob.progress._simple_progress_observer
ScopeState = namedtuple(
    "ScopeState", ["completed", "failed", "running", "total", "weighted_elapsed"]
)
from uberjob.progress._html_progress_observer import _get_total_scope_state

# unit tests

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


def test_empty_scope_states():
    # Test with an empty list; all fields should be zero
    codeflash_output = _get_total_scope_state([])
    result = codeflash_output  # 2.63μs -> 1.40μs (88.1% faster)


def test_single_scope_state():
    # Test with a single ScopeState
    s = ScopeState(completed=1, failed=2, running=3, total=4, weighted_elapsed=5)
    codeflash_output = _get_total_scope_state([s])
    result = codeflash_output  # 2.89μs -> 1.74μs (66.1% faster)


def test_multiple_scope_states_simple():
    # Test with multiple ScopeStates with simple values
    s1 = ScopeState(1, 2, 3, 4, 5)
    s2 = ScopeState(10, 20, 30, 40, 50)
    s3 = ScopeState(0, 0, 0, 0, 0)
    codeflash_output = _get_total_scope_state([s1, s2, s3])
    result = codeflash_output  # 3.21μs -> 2.09μs (53.4% faster)


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


def test_negative_values():
    # Test with negative values
    s1 = ScopeState(-1, -2, -3, -4, -5)
    s2 = ScopeState(1, 2, 3, 4, 5)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 2.97μs -> 1.93μs (53.9% faster)


def test_mixed_types_int_float():
    # Test with integer and float values
    s1 = ScopeState(1, 2, 3, 4, 5.5)
    s2 = ScopeState(10, 20, 30, 40, 0.5)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.45μs -> 2.00μs (72.0% faster)


def test_all_zero_scope_states():
    # Test with all zero ScopeStates
    s1 = ScopeState(0, 0, 0, 0, 0)
    s2 = ScopeState(0, 0, 0, 0, 0)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.01μs -> 1.88μs (60.3% faster)


def test_large_integers():
    # Test with large integer values
    big = 10**12
    s1 = ScopeState(big, big, big, big, big)
    s2 = ScopeState(big, big, big, big, big)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.15μs -> 2.28μs (38.0% faster)


def test_scope_state_with_only_weighted_elapsed_nonzero():
    # Test with only weighted_elapsed nonzero
    s1 = ScopeState(0, 0, 0, 0, 1.5)
    s2 = ScopeState(0, 0, 0, 0, 2.5)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.27μs -> 2.14μs (52.8% faster)


def test_scope_state_with_floats():
    # Test with all float fields
    s1 = ScopeState(1.1, 2.2, 3.3, 4.4, 5.5)
    s2 = ScopeState(0.9, 0.8, 0.7, 0.6, 0.5)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.30μs -> 2.12μs (55.5% faster)


def test_scope_state_with_large_number_of_fields_zero():
    # Test with many ScopeStates, all zero
    codeflash_output = _get_total_scope_state(
        [ScopeState(0, 0, 0, 0, 0) for _ in range(100)]
    )
    result = codeflash_output  # 19.5μs -> 12.1μs (61.7% faster)


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


def test_large_scale_many_scope_states():
    # Test with a large number of ScopeStates
    n = 1000
    s = ScopeState(1, 2, 3, 4, 5)
    codeflash_output = _get_total_scope_state([s for _ in range(n)])
    result = codeflash_output  # 165μs -> 120μs (37.5% faster)


def test_large_scale_varied_scope_states():
    # Test with a large number of varied ScopeStates
    n = 1000
    scope_states = [ScopeState(i, i * 2, i * 3, i * 4, i * 5) for i in range(n)]
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 168μs -> 125μs (33.7% faster)
    # Calculate expected values using formula for sum of arithmetic series
    completed = sum(i for i in range(n))
    failed = sum(i * 2 for i in range(n))
    running = sum(i * 3 for i in range(n))
    total = sum(i * 4 for i in range(n))
    weighted_elapsed = sum(i * 5 for i in range(n))


def test_large_scale_floats():
    # Test with a large number of ScopeStates with float values
    n = 500
    scope_states = [ScopeState(1.5, 2.5, 3.5, 4.5, 5.5) for _ in range(n)]
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 85.0μs -> 54.4μs (56.3% faster)


def test_large_scale_mixed_sign():
    # Test with a large number of ScopeStates with mixed positive and negative values
    n = 500
    scope_states = [ScopeState(i if i % 2 == 0 else -i, 0, 0, 0, 0) for i in range(n)]
    completed = sum(i if i % 2 == 0 else -i for i in range(n))
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 86.1μs -> 59.4μs (45.0% faster)


# ------------------ Special/Corner Cases ------------------


def test_scope_state_with_one_field_nonzero():
    # Only one field is nonzero in all ScopeStates
    scope_states = [ScopeState(0, 0, 0, 0, 10) for _ in range(10)]
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 4.51μs -> 3.13μs (44.3% faster)


def test_scope_state_with_all_fields_nonzero_and_negative():
    # All fields are negative
    scope_states = [ScopeState(-1, -1, -1, -1, -1) for _ in range(10)]
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 4.69μs -> 3.23μs (45.1% faster)


def test_scope_state_with_large_weighted_elapsed():
    # Weighted elapsed is very large
    scope_states = [ScopeState(0, 0, 0, 0, 1e9) for _ in range(10)]
    codeflash_output = _get_total_scope_state(scope_states)
    result = codeflash_output  # 4.78μs -> 3.39μs (41.0% faster)


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

from collections import namedtuple

# imports
import pytest  # used for our unit tests
from uberjob.progress._html_progress_observer import _get_total_scope_state

# function to test (from uberjob/progress/_html_progress_observer.py)
ScopeState = namedtuple(
    "ScopeState", ["completed", "failed", "running", "total", "weighted_elapsed"]
)
from uberjob.progress._html_progress_observer import _get_total_scope_state

# unit tests

# Basic Test Cases


def test_empty_scope_states():
    # Test with an empty list: all sums should be zero
    codeflash_output = _get_total_scope_state([])
    result = codeflash_output  # 2.72μs -> 1.57μs (73.3% faster)


def test_single_scope_state():
    # Test with a single ScopeState
    s = ScopeState(completed=1, failed=2, running=3, total=6, weighted_elapsed=10.5)
    codeflash_output = _get_total_scope_state([s])
    result = codeflash_output  # 3.27μs -> 2.12μs (53.7% faster)


def test_multiple_scope_states_basic():
    # Test with multiple ScopeStates with positive integers
    s1 = ScopeState(1, 2, 3, 4, 5.0)
    s2 = ScopeState(10, 20, 30, 40, 50.0)
    s3 = ScopeState(100, 200, 300, 400, 500.0)
    expected = ScopeState(
        completed=1 + 10 + 100,
        failed=2 + 20 + 200,
        running=3 + 30 + 300,
        total=4 + 40 + 400,
        weighted_elapsed=5.0 + 50.0 + 500.0,
    )
    codeflash_output = _get_total_scope_state([s1, s2, s3])
    result = codeflash_output  # 3.61μs -> 2.32μs (55.4% faster)


def test_scope_states_with_zero_values():
    # Test with ScopeStates containing zeros
    s1 = ScopeState(0, 0, 0, 0, 0.0)
    s2 = ScopeState(5, 0, 0, 0, 0.0)
    s3 = ScopeState(0, 0, 7, 0, 0.0)
    expected = ScopeState(
        completed=0 + 5 + 0,
        failed=0 + 0 + 0,
        running=0 + 0 + 7,
        total=0 + 0 + 0,
        weighted_elapsed=0.0 + 0.0 + 0.0,
    )
    codeflash_output = _get_total_scope_state([s1, s2, s3])
    result = codeflash_output  # 3.56μs -> 2.38μs (49.5% faster)


# Edge Test Cases


def test_negative_values():
    # Test with negative values (should sum normally)
    s1 = ScopeState(-1, -2, -3, -4, -5.0)
    s2 = ScopeState(1, 2, 3, 4, 5.0)
    expected = ScopeState(0, 0, 0, 0, 0.0)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.24μs -> 2.08μs (55.6% faster)


def test_mixed_types():
    # Test with ints and floats for weighted_elapsed
    s1 = ScopeState(1, 2, 3, 4, 5)
    s2 = ScopeState(10, 20, 30, 40, 50.5)
    expected = ScopeState(11, 22, 33, 44, 55.5)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.10μs -> 1.96μs (57.7% faster)


def test_large_integer_values():
    # Test with very large integer values
    big = 10**18
    s1 = ScopeState(big, big, big, big, float(big))
    s2 = ScopeState(big, big, big, big, float(big))
    expected = ScopeState(big * 2, big * 2, big * 2, big * 2, float(big * 2))
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.44μs -> 2.36μs (45.7% faster)


def test_scope_states_with_all_fields_zero():
    # All fields zero, multiple elements
    states = [ScopeState(0, 0, 0, 0, 0.0) for _ in range(10)]
    expected = ScopeState(0, 0, 0, 0, 0.0)
    codeflash_output = _get_total_scope_state(states)
    result = codeflash_output  # 4.70μs -> 3.38μs (38.9% faster)


def test_scope_states_with_minimal_and_maximal_values():
    # Minimal and maximal integer values
    import sys

    min_int = -sys.maxsize - 1
    max_int = sys.maxsize
    s1 = ScopeState(min_int, 0, 0, 0, 0.0)
    s2 = ScopeState(max_int, 0, 0, 0, 0.0)
    expected = ScopeState(min_int + max_int, 0, 0, 0, 0.0)
    codeflash_output = _get_total_scope_state([s1, s2])
    result = codeflash_output  # 3.40μs -> 2.31μs (46.8% faster)


def test_scope_states_with_non_integer_weighted_elapsed():
    # weighted_elapsed as float with decimals
    s1 = ScopeState(0, 0, 0, 0, 1.1)
    s2 = ScopeState(0, 0, 0, 0, 2.2)
    s3 = ScopeState(0, 0, 0, 0, 3.3)
    expected = ScopeState(0, 0, 0, 0, 1.1 + 2.2 + 3.3)
    codeflash_output = _get_total_scope_state([s1, s2, s3])
    result = codeflash_output  # 3.40μs -> 2.21μs (53.5% faster)


# Large Scale Test Cases


def test_large_number_of_scope_states():
    # Test with a large number of ScopeStates (1000 elements)
    n = 1000
    states = [ScopeState(1, 2, 3, 4, 5.5) for _ in range(n)]
    expected = ScopeState(
        completed=1 * n,
        failed=2 * n,
        running=3 * n,
        total=4 * n,
        weighted_elapsed=5.5 * n,
    )
    codeflash_output = _get_total_scope_state(states)
    result = codeflash_output  # 159μs -> 120μs (32.2% faster)


def test_large_scale_with_varied_values():
    # Test with 1000 ScopeStates with increasing values
    n = 1000
    states = [ScopeState(i, i * 2, i * 3, i * 4, i * 5.5) for i in range(n)]
    expected = ScopeState(
        completed=sum(i for i in range(n)),
        failed=sum(i * 2 for i in range(n)),
        running=sum(i * 3 for i in range(n)),
        total=sum(i * 4 for i in range(n)),
        weighted_elapsed=sum(i * 5.5 for i in range(n)),
    )
    codeflash_output = _get_total_scope_state(states)
    result = codeflash_output  # 166μs -> 124μs (33.8% faster)


def test_large_scale_with_mixed_signs():
    # Test with 1000 ScopeStates, half positive, half negative
    n = 1000
    half = n // 2
    pos_states = [ScopeState(1, 2, 3, 4, 5.5) for _ in range(half)]
    neg_states = [ScopeState(-1, -2, -3, -4, -5.5) for _ in range(n - half)]
    states = pos_states + neg_states
    expected = ScopeState(
        completed=1 * half + (-1) * (n - half),
        failed=2 * half + (-2) * (n - half),
        running=3 * half + (-3) * (n - half),
        total=4 * half + (-4) * (n - half),
        weighted_elapsed=5.5 * half + (-5.5) * (n - half),
    )
    codeflash_output = _get_total_scope_state(states)
    result = codeflash_output  # 164μs -> 117μs (40.2% faster)


def test_large_scale_with_random_values():
    # Test with 1000 ScopeStates with random values
    import random

    n = 1000
    random.seed(42)
    states = [
        ScopeState(
            completed=random.randint(-1000, 1000),
            failed=random.randint(-1000, 1000),
            running=random.randint(-1000, 1000),
            total=random.randint(-1000, 1000),
            weighted_elapsed=random.uniform(-1000.0, 1000.0),
        )
        for _ in range(n)
    ]
    expected = ScopeState(
        completed=sum(s.completed for s in states),
        failed=sum(s.failed for s in states),
        running=sum(s.running for s in states),
        total=sum(s.total for s in states),
        weighted_elapsed=sum(s.weighted_elapsed for s in states),
    )
    codeflash_output = _get_total_scope_state(states)
    result = codeflash_output  # 194μs -> 159μs (22.0% 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-_get_total_scope_state-mi5z4obu and push.