⚡️ Speed up method Param.as_run_param by 40%

[codeflash-ai]

📄 40% (0.40x) speedup for Param.as_run_param in higgsfield/internal/experiment/params.py

⏱️ Runtime : 726 microseconds → 520 microseconds (best of 238 runs)

📝 Explanation and details

Optimization Explanation:

• as_run_param:
  • Combines the string formatting with the bracket wrapping directly in a single f-string, removing one function call and making string building more efficient.
  • The repeated string constants ("${{ ", " }}") are hardcoded inside the f-string for both performance and clarity.
• wrap_brackets:
  • Switched to f-string formatting for "${{ " + s + " }}" pattern, which is slightly faster than normal concatenation in modern CPython.

Both changes avoid unnecessary function calls and string operations, optimizing hot paths in the profiling results—all while maintaining exactly the same output and behavioral semantics.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import Any, Optional, Tuple, Type

# imports
import pytest  # used for our unit tests
from higgsfield.internal.experiment.params import Param

pfx = "hf_action_"

# unit tests

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

def test_as_run_param_basic_name():
    # Basic scenario with a simple name
    param = Param(name="foo")
    expected = 'hf_action_foo="${{ github.event.inputs.foo }}"'
    codeflash_output = param.as_run_param() # 1.40μs -> 980ns (42.6% faster)

def test_as_run_param_basic_name_with_default():
    # Basic scenario with default value (should not affect output)
    param = Param(name="bar", default=123)
    expected = 'hf_action_bar="${{ github.event.inputs.bar }}"'
    codeflash_output = param.as_run_param() # 1.26μs -> 907ns (38.8% faster)

def test_as_run_param_basic_name_with_description():
    # Basic scenario with description (should not affect output)
    param = Param(name="baz", description="A parameter")
    expected = 'hf_action_baz="${{ github.event.inputs.baz }}"'
    codeflash_output = param.as_run_param() # 1.23μs -> 847ns (44.9% faster)

def test_as_run_param_basic_all_fields():
    # All fields set, only name matters for output
    param = Param(
        name="qux",
        default="abc",
        description="desc",
        required=True,
        type=str,
        options=("abc", "def")
    )
    expected = 'hf_action_qux="${{ github.event.inputs.qux }}"'
    codeflash_output = param.as_run_param() # 1.20μs -> 863ns (38.6% faster)

# -------------------- EDGE TEST CASES --------------------

def test_as_run_param_empty_name():
    # Edge case: empty string as name
    param = Param(name="")
    expected = 'hf_action_="${{ github.event.inputs. }}"'
    codeflash_output = param.as_run_param() # 1.17μs -> 738ns (58.7% faster)

def test_as_run_param_name_with_spaces():
    # Edge case: name with spaces
    param = Param(name="my param")
    expected = 'hf_action_my param="${{ github.event.inputs.my param }}"'
    codeflash_output = param.as_run_param() # 1.22μs -> 846ns (44.0% faster)

def test_as_run_param_name_with_special_chars():
    # Edge case: name with special characters
    param = Param(name="na$me@123")
    expected = 'hf_action_na$me@123="${{ github.event.inputs.na$me@123 }}"'
    codeflash_output = param.as_run_param() # 1.15μs -> 764ns (51.0% faster)

def test_as_run_param_name_with_unicode():
    # Edge case: name with unicode characters
    param = Param(name="π_变量")
    expected = 'hf_action_π_变量="${{ github.event.inputs.π_变量 }}"'
    codeflash_output = param.as_run_param() # 1.84μs -> 1.31μs (40.7% faster)

def test_as_run_param_name_with_long_string():
    # Edge case: very long name string (256 chars)
    long_name = "a" * 256
    param = Param(name=long_name)
    expected = f'hf_action_{long_name}="${{ github.event.inputs.{long_name} }}"'
    codeflash_output = param.as_run_param() # 1.31μs -> 932ns (40.6% faster)

def test_as_run_param_name_with_leading_trailing_spaces():
    # Edge case: name with leading/trailing whitespace
    param = Param(name="  spaced  ")
    expected = 'hf_action_  spaced  ="${{ github.event.inputs.  spaced  }}"'
    codeflash_output = param.as_run_param() # 1.18μs -> 767ns (54.4% faster)

def test_as_run_param_name_is_none():
    # Edge case: name is None (should raise AttributeError or TypeError)
    param = Param(name=None)
    with pytest.raises(TypeError):
        # None cannot be concatenated to strings
        param.as_run_param() # 1.87μs -> 1.53μs (21.6% faster)

def test_as_run_param_name_is_integer():
    # Edge case: name is an integer (should raise TypeError)
    param = Param(name=123)
    with pytest.raises(TypeError):
        param.as_run_param() # 1.66μs -> 1.39μs (19.4% faster)

def test_as_run_param_name_is_bool():
    # Edge case: name is a boolean (should raise TypeError)
    param = Param(name=True)
    with pytest.raises(TypeError):
        param.as_run_param() # 2.10μs -> 1.31μs (60.2% faster)

def test_as_run_param_name_is_tuple():
    # Edge case: name is a tuple (should raise TypeError)
    param = Param(name=("tuple",))
    with pytest.raises(TypeError):
        param.as_run_param() # 2.91μs -> 1.32μs (120% faster)

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

def test_as_run_param_many_params():
    # Large scale: create many Param objects and check outputs
    for i in range(1000):
        name = f"param_{i}"
        param = Param(name=name)
        expected = f'hf_action_{name}="${{ github.event.inputs.{name} }}"'
        codeflash_output = param.as_run_param() # 336μs -> 237μs (41.4% faster)

def test_as_run_param_long_names():
    # Large scale: names of increasing length up to 1000 chars
    for length in [1, 10, 100, 500, 1000]:
        name = "x" * length
        param = Param(name=name)
        expected = f'hf_action_{name}="${{ github.event.inputs.{name} }}"'
        codeflash_output = param.as_run_param() # 4.28μs -> 2.88μs (48.7% faster)

def test_as_run_param_performance_large():
    # Performance: ensure function does not hang with 1000 params
    params = [Param(name=f"p{i}") for i in range(1000)]
    results = [p.as_run_param() for p in params]
    # Check that all outputs are correct
    for i, res in enumerate(results):
        expected = f'hf_action_p{i}="${{ github.event.inputs.p{i} }}"'

# -------------------- ADDITIONAL EDGE CASES --------------------

def test_as_run_param_name_is_empty_str_and_spaces():
    # Edge: name is empty string with only spaces
    param = Param(name="   ")
    expected = 'hf_action_   ="${{ github.event.inputs.   }}"'
    codeflash_output = param.as_run_param() # 1.48μs -> 1.14μs (30.5% faster)

def test_as_run_param_name_is_str_none():
    # Edge: name is string "None"
    param = Param(name="None")
    expected = 'hf_action_None="${{ github.event.inputs.None }}"'
    codeflash_output = param.as_run_param() # 1.27μs -> 932ns (36.6% faster)

def test_as_run_param_name_is_str_true_false():
    # Edge: name is string "True" or "False"
    param_true = Param(name="True")
    param_false = Param(name="False")
    expected_true = 'hf_action_True="${{ github.event.inputs.True }}"'
    expected_false = 'hf_action_False="${{ github.event.inputs.False }}"'
    codeflash_output = param_true.as_run_param() # 1.26μs -> 888ns (42.5% faster)
    codeflash_output = param_false.as_run_param() # 655ns -> 383ns (71.0% faster)

def test_as_run_param_name_with_newlines_tabs():
    # Edge: name contains newlines and tabs
    param = Param(name="line1\nline2\tend")
    expected = 'hf_action_line1\nline2\tend="${{ github.event.inputs.line1\nline2\tend }}"'
    codeflash_output = param.as_run_param() # 1.22μs -> 896ns (36.3% faster)

def test_as_run_param_name_with_quotes():
    # Edge: name contains quotes
    param = Param(name='param"with\'quotes')
    expected = 'hf_action_param"with\'quotes="${{ github.event.inputs.param"with\'quotes }}"'
    codeflash_output = param.as_run_param() # 1.22μs -> 800ns (52.2% faster)
# 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, Optional, Tuple, Type

# imports
import pytest  # used for our unit tests
from higgsfield.internal.experiment.params import Param

pfx = "hf_action_"

# unit tests

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

def test_basic_single_param():
    """Test with a simple parameter name."""
    p = Param(name="foo")
    expected = 'hf_action_foo="${{ github.event.inputs.foo }}"'
    codeflash_output = p.as_run_param() # 1.24μs -> 914ns (35.3% faster)

def test_basic_param_with_default():
    """Test that default value does not affect as_run_param output."""
    p = Param(name="bar", default=123)
    expected = 'hf_action_bar="${{ github.event.inputs.bar }}"'
    codeflash_output = p.as_run_param() # 1.18μs -> 818ns (43.6% faster)

def test_basic_param_with_description():
    """Test that description does not affect as_run_param output."""
    p = Param(name="baz", description="A test param")
    expected = 'hf_action_baz="${{ github.event.inputs.baz }}"'
    codeflash_output = p.as_run_param() # 1.17μs -> 826ns (41.5% faster)

def test_basic_param_with_type_and_options():
    """Test that type and options do not affect as_run_param output."""
    p = Param(name="qux", type=int, options=(1,2,3))
    expected = 'hf_action_qux="${{ github.event.inputs.qux }}"'
    codeflash_output = p.as_run_param() # 1.09μs -> 842ns (29.1% faster)

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

def test_edge_empty_name():
    """Test with an empty string as name."""
    p = Param(name="")
    expected = 'hf_action_="${{ github.event.inputs. }}"'
    codeflash_output = p.as_run_param() # 1.16μs -> 755ns (53.9% faster)

def test_edge_special_characters_in_name():
    """Test with name containing special characters."""
    p = Param(name="foo-bar_123")
    expected = 'hf_action_foo-bar_123="${{ github.event.inputs.foo-bar_123 }}"'
    codeflash_output = p.as_run_param() # 1.22μs -> 833ns (46.5% faster)

def test_edge_name_with_spaces():
    """Test with name containing spaces."""
    p = Param(name="my param")
    expected = 'hf_action_my param="${{ github.event.inputs.my param }}"'
    codeflash_output = p.as_run_param() # 1.16μs -> 828ns (40.5% faster)

def test_edge_name_with_unicode():
    """Test with name containing unicode characters."""
    p = Param(name="参数")
    expected = 'hf_action_参数="${{ github.event.inputs.参数 }}"'
    codeflash_output = p.as_run_param() # 1.93μs -> 1.32μs (46.3% faster)

def test_edge_name_with_quotes():
    """Test with name containing quotes."""
    p = Param(name='foo"bar')
    expected = 'hf_action_foo"bar="${{ github.event.inputs.foo"bar }}"'
    codeflash_output = p.as_run_param() # 1.23μs -> 831ns (47.5% faster)

def test_edge_name_with_brackets():
    """Test with name containing brackets."""
    p = Param(name="foo[bar]")
    expected = 'hf_action_foo[bar]="${{ github.event.inputs.foo[bar] }}"'
    codeflash_output = p.as_run_param() # 1.13μs -> 824ns (37.1% faster)

def test_edge_required_true():
    """Test that required True does not affect as_run_param output."""
    p = Param(name="req", required=True)
    expected = 'hf_action_req="${{ github.event.inputs.req }}"'
    codeflash_output = p.as_run_param() # 1.21μs -> 794ns (51.8% faster)

def test_edge_none_name():
    """Test with None as name should raise TypeError."""
    with pytest.raises(TypeError):
        Param(name=None).as_run_param() # 1.82μs -> 1.46μs (24.7% faster)

def test_edge_missing_name():
    """Test with missing name should raise TypeError."""
    with pytest.raises(TypeError):
        Param().as_run_param()

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

def test_large_number_of_params():
    """Test as_run_param for many different parameter names."""
    for i in range(1000):
        name = f"param{i}"
        p = Param(name=name)
        expected = f'hf_action_{name}="${{ github.event.inputs.{name} }}"'
        codeflash_output = p.as_run_param() # 334μs -> 243μs (37.3% faster)

def test_large_param_name():
    """Test with a very long parameter name."""
    long_name = "x" * 500
    p = Param(name=long_name)
    expected = f'hf_action_{long_name}="${{ github.event.inputs.{long_name} }}"'
    codeflash_output = p.as_run_param() # 1.79μs -> 1.25μs (42.5% faster)

def test_large_param_name_with_special_chars():
    """Test with a very long parameter name containing special characters."""
    long_name = "!" * 500
    p = Param(name=long_name)
    expected = f'hf_action_{long_name}="${{ github.event.inputs.{long_name} }}"'
    codeflash_output = p.as_run_param() # 1.50μs -> 1.08μs (38.8% faster)

def test_large_param_name_with_spaces():
    """Test with a very long parameter name containing spaces."""
    long_name = "long name " * 50  # 500 chars approx
    p = Param(name=long_name)
    expected = f'hf_action_{long_name}="${{ github.event.inputs.{long_name} }}"'
    codeflash_output = p.as_run_param() # 1.55μs -> 1.07μs (45.6% faster)

def test_large_options_tuple():
    """Test with a large options tuple to ensure it doesn't affect output."""
    options = tuple(range(1000))
    p = Param(name="bigoptions", options=options)
    expected = 'hf_action_bigoptions="${{ github.event.inputs.bigoptions }}"'
    codeflash_output = p.as_run_param() # 1.27μs -> 899ns (41.3% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from higgsfield.internal.experiment.params import Param
import pytest

def test_Param_as_run_param():
    with pytest.raises(AttributeError, match="'Param'\\ object\\ has\\ no\\ attribute\\ 'name'"):
        Param.as_run_param(Param())

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0kzwu12q/tmpp12mxbmg/test_concolic_coverage.py::test_Param_as_run_param	1.45μs	1.42μs	1.62%✅

To edit these changes git checkout codeflash/optimize-Param.as_run_param-mglonz7b and push.