⚡️ Speed up function insert_env_line by 71%

[codeflash-ai]

📄 71% (0.71x) speedup for insert_env_line in higgsfield/internal/experiment/builder.py

⏱️ Runtime : 551 microseconds → 322 microseconds (best of 514 runs)

📝 Explanation and details

The optimized code achieves a 71% speedup by replacing string concatenation with f-strings and using a list comprehension instead of a for loop with explicit appends.

Key optimizations:

1. F-string formatting: The original code uses string concatenation (indent + "echo " + key + '="${{ secrets.' + key + ' }}" >> env') which creates multiple intermediate string objects. The optimized version uses a single f-string that performs the interpolation in one operation.

2. List comprehension: Instead of initializing an empty list and repeatedly calling append() in a loop, the optimized code uses a list comprehension to build the entire list in a single, more efficient operation.

Why this is faster:

• String concatenation in Python creates new string objects at each + operation due to string immutability, leading to O(n²) behavior for multiple concatenations
• F-strings are internally optimized and avoid intermediate string creation
• List comprehensions are implemented in C and avoid the overhead of repeated method calls to append()
• The line profiler shows the string building operation went from 46.1% of runtime to being absorbed into the list comprehension

Performance characteristics:

• Small inputs (1-5 keys): Modest improvements of 1-6% faster, sometimes slightly slower due to f-string overhead
• Large inputs (100+ keys): Dramatic improvements of 70-95% faster, where the O(n²) string concatenation penalty becomes severe
• Empty inputs: Slightly slower (~35-40%) due to list comprehension setup overhead, but this is negligible in absolute terms (microseconds)

This optimization is particularly effective for the large-scale test cases that generate hundreds of environment variable lines.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from typing import List

# imports
import pytest  # used for our unit tests
from higgsfield.internal.experiment.builder import insert_env_line

# unit tests

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

def test_single_key_no_indent():
    # Test with a single key and no indentation
    codeflash_output = insert_env_line(['MY_KEY'], ''); result = codeflash_output # 1.05μs -> 1.11μs (5.65% slower)
    expected = 'echo MY_KEY="${{ secrets.MY_KEY }}" >> env'

def test_single_key_with_indent():
    # Test with a single key and some indentation
    codeflash_output = insert_env_line(['API_KEY'], '    '); result = codeflash_output # 1.08μs -> 1.12μs (3.93% slower)
    expected = '    echo API_KEY="${{ secrets.API_KEY }}" >> env'

def test_multiple_keys_no_indent():
    # Test with multiple keys and no indentation
    keys = ['A', 'B', 'C']
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 1.70μs -> 1.62μs (4.86% faster)
    expected = (
        'echo A="${{ secrets.A }}" >> env\n'
        'echo B="${{ secrets.B }}" >> env\n'
        'echo C="${{ secrets.C }}" >> env'
    )

def test_multiple_keys_with_indent():
    # Test with multiple keys and indentation
    keys = ['X', 'Y']
    codeflash_output = insert_env_line(keys, '\t'); result = codeflash_output # 1.49μs -> 1.47μs (1.36% faster)
    expected = (
        '\techo X="${{ secrets.X }}" >> env\n'
        '\techo Y="${{ secrets.Y }}" >> env'
    )

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

def test_empty_keys_list():
    # Test with an empty keys list
    codeflash_output = insert_env_line([], '  '); result = codeflash_output # 546ns -> 841ns (35.1% slower)

def test_empty_indent():
    # Test with empty indent and multiple keys
    keys = ['K1', 'K2']
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 1.45μs -> 1.44μs (0.767% faster)
    expected = (
        'echo K1="${{ secrets.K1 }}" >> env\n'
        'echo K2="${{ secrets.K2 }}" >> env'
    )

def test_empty_string_key():
    # Test with an empty string as a key
    codeflash_output = insert_env_line([''], '  '); result = codeflash_output # 986ns -> 1.14μs (13.1% slower)
    expected = '  echo ="${{ secrets. }}" >> env'

def test_key_with_special_characters():
    # Test with a key containing special characters
    key = 'MY-KEY_123
    codeflash_output = insert_env_line([key], ''); result = codeflash_output # 1.01μs -> 1.11μs (9.12% slower)
    expected = 'echo MY-KEY_123$="${{ secrets.MY-KEY_123$ }}" >> env'

def test_indent_with_special_characters():
    # Test with indent containing special characters (e.g., tabs, spaces, symbols)
    indent = '\t  ##'
    codeflash_output = insert_env_line(['KEY'], indent); result = codeflash_output # 1.01μs -> 1.11μs (8.72% slower)
    expected = '\t  ##echo KEY="${{ secrets.KEY }}" >> env'

def test_keys_with_spaces():
    # Test with keys that include spaces
    keys = ['KEY WITH SPACE', 'ANOTHER KEY']
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 1.55μs -> 1.40μs (10.8% faster)
    expected = (
        'echo KEY WITH SPACE="${{ secrets.KEY WITH SPACE }}" >> env\n'
        'echo ANOTHER KEY="${{ secrets.ANOTHER KEY }}" >> env'
    )

def test_indent_is_empty_string():
    # Test with indent as an empty string
    codeflash_output = insert_env_line(['KEY'], ''); result = codeflash_output # 988ns -> 1.09μs (9.27% slower)
    expected = 'echo KEY="${{ secrets.KEY }}" >> env'

def test_indent_is_whitespace():
    # Test with indent as whitespace
    codeflash_output = insert_env_line(['KEY'], '   '); result = codeflash_output # 1.00μs -> 1.12μs (10.1% slower)
    expected = '   echo KEY="${{ secrets.KEY }}" >> env'

def test_key_is_numeric_string():
    # Test with key as a numeric string
    codeflash_output = insert_env_line(['123'], ''); result = codeflash_output # 926ns -> 1.10μs (15.7% slower)
    expected = 'echo 123="${{ secrets.123 }}" >> env'

def test_key_is_empty_and_indent_is_empty():
    # Test with both key and indent as empty strings
    codeflash_output = insert_env_line([''], ''); result = codeflash_output # 884ns -> 1.09μs (19.3% slower)
    expected = 'echo ="${{ secrets. }}" >> env'

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

def test_large_number_of_keys():
    # Test with a large number of keys (e.g., 1000 keys)
    keys = [f'KEY{i}' for i in range(1000)]
    indent = '  '
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 154μs -> 84.2μs (83.0% faster)
    # Check that the result has 1000 lines
    lines = result.split('\n')

def test_large_keys_with_long_names():
    # Test with a large number of keys with long names
    keys = [f'LONG_KEY_NAME_{i}_{"X"*50}' for i in range(500)]
    indent = '    '
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 88.9μs -> 49.5μs (79.7% faster)
    lines = result.split('\n')
    # Check a random line for correctness
    idx = 123
    key = keys[idx]
    expected_line = f'    echo {key}="${{ secrets.{key} }}" >> env'

def test_large_indent_and_large_keys():
    # Test with a large indent and large number of keys
    indent = ' ' * 50  # 50 spaces
    keys = [f'K{i}' for i in range(100)]
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 15.9μs -> 9.09μs (74.7% faster)
    lines = result.split('\n')
    # Each line should start with 50 spaces
    for line in lines:
        pass

def test_large_keys_with_special_chars():
    # Test with a large number of keys with special characters
    keys = [f'KEY_{i}_$%&' for i in range(200)]
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 27.5μs -> 15.6μs (75.9% faster)
    lines = result.split('\n')
    for i, key in enumerate(keys):
        expected_line = f'echo {key}="${{ secrets.{key} }}" >> env'

# ---------------------------
# Additional Robustness Tests
# ---------------------------

def test_keys_with_duplicate_entries():
    # Test with duplicate keys in the list
    keys = ['DUP', 'DUP', 'DUP']
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 1.67μs -> 1.58μs (5.18% faster)
    expected = (
        'echo DUP="${{ secrets.DUP }}" >> env\n'
        'echo DUP="${{ secrets.DUP }}" >> env\n'
        'echo DUP="${{ secrets.DUP }}" >> env'
    )

def test_keys_with_mixed_types():
    # Test with keys as string representations of different types
    keys = ['True', 'None', 'False', '123', 'key']
    codeflash_output = insert_env_line(keys, ''); result = codeflash_output # 2.08μs -> 1.97μs (5.84% faster)
    expected = (
        'echo True="${{ secrets.True }}" >> env\n'
        'echo None="${{ secrets.None }}" >> env\n'
        'echo False="${{ secrets.False }}" >> env\n'
        'echo 123="${{ secrets.123 }}" >> env\n'
        'echo key="${{ secrets.key }}" >> env'
    )
# 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 List

# imports
import pytest  # used for our unit tests
from higgsfield.internal.experiment.builder import insert_env_line

# unit tests

# 1. Basic Test Cases

def test_single_key_no_indent():
    # Test with a single key, no indentation
    keys = ["MY_SECRET"]
    indent = ""
    expected = 'echo MY_SECRET="${{ secrets.MY_SECRET }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 1.02μs -> 1.29μs (21.1% slower)

def test_single_key_with_indent():
    # Test with a single key and indentation
    keys = ["API_KEY"]
    indent = "    "
    expected = '    echo API_KEY="${{ secrets.API_KEY }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 1.13μs -> 1.13μs (0.088% faster)

def test_multiple_keys_no_indent():
    # Test with multiple keys, no indentation
    keys = ["KEY1", "KEY2", "KEY3"]
    indent = ""
    expected = (
        'echo KEY1="${{ secrets.KEY1 }}" >> env\n'
        'echo KEY2="${{ secrets.KEY2 }}" >> env\n'
        'echo KEY3="${{ secrets.KEY3 }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.72μs -> 1.62μs (5.98% faster)

def test_multiple_keys_with_indent():
    # Test with multiple keys and indentation
    keys = ["FOO", "BAR"]
    indent = "\t"
    expected = (
        '\techo FOO="${{ secrets.FOO }}" >> env\n'
        '\techo BAR="${{ secrets.BAR }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.48μs -> 1.52μs (2.37% slower)

def test_empty_keys_list():
    # Test with an empty list of keys
    keys = []
    indent = "  "
    expected = ""
    codeflash_output = insert_env_line(keys, indent) # 509ns -> 846ns (39.8% slower)

# 2. Edge Test Cases

def test_key_with_special_characters():
    # Test with keys containing special characters
    keys = ["SECRET-1", "SECRET_2", "SECRET.3", "SECRET$4"]
    indent = ""
    expected = (
        'echo SECRET-1="${{ secrets.SECRET-1 }}" >> env\n'
        'echo SECRET_2="${{ secrets.SECRET_2 }}" >> env\n'
        'echo SECRET.3="${{ secrets.SECRET.3 }}" >> env\n'
        'echo SECRET$4="${{ secrets.SECRET$4 }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.86μs -> 1.74μs (6.83% faster)

def test_indent_is_empty_string():
    # Test with indent as an empty string
    keys = ["ENV"]
    indent = ""
    expected = 'echo ENV="${{ secrets.ENV }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 976ns -> 1.12μs (12.5% slower)

def test_indent_is_spaces():
    # Test with indent as spaces
    keys = ["VAR"]
    indent = "   "
    expected = '   echo VAR="${{ secrets.VAR }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 1.02μs -> 1.12μs (8.42% slower)

def test_indent_is_tab():
    # Test with indent as a tab character
    keys = ["TABKEY"]
    indent = "\t"
    expected = '\techo TABKEY="${{ secrets.TABKEY }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 1.04μs -> 1.07μs (3.26% slower)

def test_key_is_empty_string():
    # Test with a key as an empty string
    keys = [""]
    indent = ""
    expected = 'echo ="${{ secrets. }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 935ns -> 1.03μs (9.31% slower)

def test_keys_with_whitespace():
    # Test with keys containing whitespace
    keys = ["KEY WITH SPACE", " ANOTHER"]
    indent = ""
    expected = (
        'echo KEY WITH SPACE="${{ secrets.KEY WITH SPACE }}" >> env\n'
        'echo  ANOTHER="${{ secrets. ANOTHER }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.52μs -> 1.46μs (3.90% faster)

def test_keys_with_unicode():
    # Test with unicode characters in keys
    keys = ["ключ", "密钥", "🔑"]
    indent = ""
    expected = (
        'echo ключ="${{ secrets.ключ }}" >> env\n'
        'echo 密钥="${{ secrets.密钥 }}" >> env\n'
        'echo 🔑="${{ secrets.🔑 }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 2.78μs -> 2.55μs (8.77% faster)

def test_indent_unicode():
    # Test with unicode characters in indent
    keys = ["UNICODE"]
    indent = "🔥"
    expected = '🔥echo UNICODE="${{ secrets.UNICODE }}" >> env'
    codeflash_output = insert_env_line(keys, indent) # 1.25μs -> 1.38μs (9.22% slower)

def test_keys_with_numbers_only():
    # Test with keys that are numbers as strings
    keys = ["123", "456"]
    indent = ""
    expected = (
        'echo 123="${{ secrets.123 }}" >> env\n'
        'echo 456="${{ secrets.456 }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.48μs -> 1.43μs (3.14% faster)

def test_keys_with_mixed_case():
    # Test with keys that have mixed case
    keys = ["lower", "UPPER", "MiXeD"]
    indent = ""
    expected = (
        'echo lower="${{ secrets.lower }}" >> env\n'
        'echo UPPER="${{ secrets.UPPER }}" >> env\n'
        'echo MiXeD="${{ secrets.MiXeD }}" >> env'
    )
    codeflash_output = insert_env_line(keys, indent) # 1.66μs -> 1.61μs (2.86% faster)

# 3. Large Scale Test Cases

def test_large_number_of_keys():
    # Test with a large number of keys (up to 1000)
    keys = [f"KEY{i}" for i in range(1000)]
    indent = ""
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 125μs -> 68.0μs (84.8% faster)
    # Check the number of lines matches the number of keys
    lines = result.split("\n")

def test_large_number_of_keys_with_indent():
    # Test with a large number of keys and indentation
    keys = [f"VAR{i}" for i in range(500)]
    indent = "  "
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 68.3μs -> 35.2μs (93.9% faster)
    lines = result.split("\n")

def test_large_keys_and_long_indent():
    # Test with long keys and a long indent string
    keys = [f"LONGKEY_{'A'*50}_{i}" for i in range(10)]
    indent = " " * 50
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 3.67μs -> 2.56μs (43.2% faster)
    lines = result.split("\n")
    for i, line in enumerate(lines):
        expected = (
            " " * 50
            + f'echo LONGKEY_{"A"*50}_{i}="${{ secrets.LONGKEY_{"A"*50}_{i} }}" >> env'
        )

def test_large_keys_with_special_characters():
    # Test with many keys containing special characters
    keys = [f"KEY_{i}_$!@#" for i in range(200)]
    indent = ""
    codeflash_output = insert_env_line(keys, indent); result = codeflash_output # 26.6μs -> 15.5μs (72.0% faster)
    lines = result.split("\n")
    for i, line in enumerate(lines):
        expected = f'echo KEY_{i}_$!@#="${{ secrets.KEY_{i}_$!@# }}" >> env'
# 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.builder import insert_env_line

def test_insert_env_line():
    insert_env_line([''], '')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_3jg4m0fg/tmp5tjgx65n/test_concolic_coverage.py::test_insert_env_line	962ns	1.14μs	-15.8%⚠️

To edit these changes git checkout codeflash/optimize-insert_env_line-mglmq131 and push.