⚡️ Speed up function generate__notify by 38%

[codeflash-ai]

📄 38% (0.38x) speedup for generate__notify in bench_runner/scripts/install.py

⏱️ Runtime : 2.14 milliseconds → 1.55 millisecond (best of 111 runs)

📝 Explanation and details

To optimize the given Python program, let's focus on the processing inside the loop and avoid redundant operations.

1. The function flag_env() is called multiple times within the nested loop, which introduces unnecessary redundancy.
2. Since flag_env() computes the same result every time it's called, we can compute it once and reuse the result.
3. Let's apply these optimizations.

Here's the optimized version of your program.

In this optimized version.

• The flag_env() is called once and its result is stored in flag_value within the add_flag_env function, thereby avoiding multiple redundant calls.
• This reduces the overall time complexity and improves the program’s runtime performance.

This refactoring maintains the functionality while optimizing for performance.

✅ Correctness verification report:

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

🌀 Generated Regression Tests Details

from typing import Any
from unittest.mock import Mock, patch

# imports
import pytest  # used for our unit tests
# function to test
from bench_runner import flags
from bench_runner.scripts.install import generate__notify


# Mock flag and flag_env for testing
class MockFlag:
    def __init__(self, gha_variable, description):
        self.gha_variable = gha_variable
        self.description = description

def flag_env():
    return "mocked_flag_env"

# unit tests
def test_minimal_valid_input():
    dst = {"on": {"workflow_call": {"inputs": {}}}, "jobs": {}}
    flags.FLAGS = [MockFlag("test_flag", "A test flag")]
    codeflash_output = generate__notify(dst)

def test_standard_valid_input():
    dst = {
        "on": {"workflow_call": {"inputs": {}}},
        "jobs": {
            "job1": {
                "steps": [
                    {"run": "echo Hello World"}
                ]
            }
        }
    }
    flags.FLAGS = [MockFlag("test_flag", "A test flag")]
    codeflash_output = generate__notify(dst)

def test_empty_input():
    dst = {}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_missing_on_key():
    dst = {"jobs": {}}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_missing_workflow_call_key():
    dst = {"on": {}, "jobs": {}}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_missing_inputs_key():
    dst = {"on": {"workflow_call": {}}, "jobs": {}}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_missing_jobs_key():
    dst = {"on": {"workflow_call": {"inputs": {}}}}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_nested_jobs_and_steps():
    dst = {
        "on": {"workflow_call": {"inputs": {}}},
        "jobs": {
            "job1": {
                "steps": [
                    {"run": "echo Hello World"},
                    {"name": "Check out code", "uses": "actions/checkout@v2"}
                ]
            },
            "job2": {
                "steps": [
                    {"run": "echo Goodbye World"}
                ],
                "env": {"EXISTING_VAR": "value"}
            }
        }
    }
    flags.FLAGS = [MockFlag("test_flag", "A test flag")]
    codeflash_output = generate__notify(dst)

def test_invalid_flags_module():
    flags.FLAGS = None
    dst = {"on": {"workflow_call": {"inputs": {}}}, "jobs": {}}
    with pytest.raises(TypeError):
        generate__notify(dst)


def test_invalid_dst_types():
    with pytest.raises(TypeError):
        generate__notify([])

    with pytest.raises(TypeError):
        generate__notify("invalid")

    with pytest.raises(TypeError):
        generate__notify(42)

def test_large_number_of_flags():
    flags.FLAGS = [MockFlag(f"flag{i}", f"description{i}") for i in range(1000)]
    dst = {"on": {"workflow_call": {"inputs": {}}}, "jobs": {}}
    codeflash_output = generate__notify(dst)
    for i in range(1000):
        pass

def test_large_number_of_jobs_and_steps():
    dst = {
        "on": {"workflow_call": {"inputs": {}}},
        "jobs": {
            f"job{i}": {
                "steps": [{"run": f"echo Step {j}"} for j in range(100)]
            } for i in range(100)
        }
    }
    flags.FLAGS = [MockFlag("test_flag", "A test flag")]
    codeflash_output = generate__notify(dst)
    for i in range(100):
        for j in range(100):
            pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from typing import Any
from unittest.mock import Mock

# imports
import pytest  # used for our unit tests
# function to test
from bench_runner import flags
from bench_runner.scripts.install import generate__notify


# Mock flag_env function
def flag_env():
    return "mocked_flag_env"

# Mock Flag class for testing
class MockFlag:
    def __init__(self, gha_variable, description, default=False):
        self.gha_variable = gha_variable
        self.description = description
        self.default = default

# unit tests

def test_minimal_valid_input():
    # Minimal valid input
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {}
    }
    codeflash_output = generate__notify(dst)

def test_typical_valid_input():
    # Typical valid input
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {
                    "existing_input": {
                        "description": "An existing input",
                        "type": "string",
                        "default": "default_value"
                    }
                }
            }
        },
        "jobs": {
            "job1": {
                "steps": [
                    {
                        "name": "Step 1",
                        "run": "echo Hello"
                    }
                ]
            }
        }
    }
    flags.FLAGS = [MockFlag(gha_variable="flag1", description="Flag 1")]
    codeflash_output = generate__notify(dst)

def test_empty_dst():
    # Empty dst dictionary
    dst = {}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_missing_keys_in_dst():
    # Missing "on" key
    dst = {}
    with pytest.raises(KeyError):
        generate__notify(dst)

    # Missing "workflow_call" key
    dst = {"on": {}}
    with pytest.raises(KeyError):
        generate__notify(dst)

    # Missing "inputs" key
    dst = {"on": {"workflow_call": {}}}
    with pytest.raises(KeyError):
        generate__notify(dst)

    # Missing "jobs" key
    dst = {"on": {"workflow_call": {"inputs": {}}}}
    with pytest.raises(KeyError):
        generate__notify(dst)

def test_empty_jobs_dictionary():
    # Empty jobs dictionary
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {}
    }
    codeflash_output = generate__notify(dst)

def test_multiple_jobs_with_steps():
    # Multiple jobs with steps
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {
            "job1": {
                "steps": [
                    {"name": "Step 1", "run": "echo Hello"},
                    {"name": "Step 2", "run": "echo World"}
                ]
            },
            "job2": {
                "steps": [
                    {"name": "Step 1", "run": "echo Foo"},
                    {"name": "Step 2", "run": "echo Bar"}
                ]
            }
        }
    }
    flags.FLAGS = [MockFlag(gha_variable="flag1", description="Flag 1")]
    codeflash_output = generate__notify(dst)



def test_no_flags_defined():
    # No flags defined
    flags.FLAGS = []
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {}
    }
    codeflash_output = generate__notify(dst)

def test_multiple_flags_defined():
    # Multiple flags defined
    flags.FLAGS = [
        MockFlag(gha_variable="flag1", description="Flag 1"),
        MockFlag(gha_variable="flag2", description="Flag 2")
    ]
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {}
    }
    codeflash_output = generate__notify(dst)

def test_large_number_of_flags():
    # Large number of flags
    flags.FLAGS = [MockFlag(gha_variable=f"flag{i}", description=f"Flag {i}") for i in range(1000)]
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {}
    }
    codeflash_output = generate__notify(dst)
    for i in range(1000):
        pass

def test_large_number_of_jobs_and_steps():
    # Large number of jobs and steps
    dst = {
        "on": {
            "workflow_call": {
                "inputs": {}
            }
        },
        "jobs": {
            f"job{i}": {
                "steps": [
                    {"name": f"Step {j}", "run": f"echo Step {j}"} for j in range(100)
                ]
            } for i in range(100)
        }
    }
    flags.FLAGS = [MockFlag(gha_variable="flag1", description="Flag 1")]
    codeflash_output = generate__notify(dst)
    for i in range(100):
        pass
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from bench_runner.scripts.install import generate__notify
import pytest

def test_generate__notify():
    with pytest.raises(TypeError, match="<class\\ 'str'>"):
        generate__notify('')

📢 Feedback on this optimization?