⚡️ Speed up function get_str_env by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for get_str_env in src/config/loader.py

⏱️ Runtime : 1.72 milliseconds → 1.58 milliseconds (best of 116 runs)

📝 Explanation and details

The optimization replaces os.getenv(name) with os.environ.get(name) and removes an unnecessary str() conversion, achieving an 8% speedup.

Key changes:

1. Direct dictionary access: os.environ.get(name) accesses the environment variables dictionary directly, avoiding the function call overhead of os.getenv(name)
2. Eliminated redundant conversion: Removed str(val) since os.environ.get() already returns a string or None - the str() wrapper was unnecessary overhead

Why this is faster:

• os.environ is a mapping object that provides direct dictionary-like access, while os.getenv() adds a function call layer
• Removing the str() conversion eliminates a redundant operation since environment variables are always strings in Python's os.environ

Performance characteristics from tests:

• Most effective for frequent environment variable lookups (10-30% faster in individual calls)
• Particularly good for batch processing scenarios where many variables are accessed sequentially (10-11% improvement in bulk tests)
• Benefits are consistent across different value types (unicode, long strings, whitespace-heavy values)
• Even missing variables show 4-19% improvements due to the more efficient lookup mechanism

The optimization maintains identical behavior while reducing computational overhead through more direct API usage.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

import os
import random
import string

# imports
import pytest
from src.config.loader import get_str_env

# unit tests

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

def test_env_var_exists_returns_value():
    # Test that function returns the value of the env var if it exists
    os.environ["TEST_ENV"] = "hello"
    codeflash_output = get_str_env("TEST_ENV") # 1.79μs -> 1.43μs (25.3% faster)

def test_env_var_exists_returns_value_with_default():
    # Test that function returns the value even if a default is provided
    os.environ["TEST_ENV"] = "world"
    codeflash_output = get_str_env("TEST_ENV", default="default") # 1.76μs -> 1.36μs (29.5% faster)

def test_env_var_does_not_exist_returns_default():
    # Test that function returns default if env var is not set
    if "NOT_EXISTING_ENV" in os.environ:
        del os.environ["NOT_EXISTING_ENV"]
    codeflash_output = get_str_env("NOT_EXISTING_ENV", default="fallback") # 1.70μs -> 1.49μs (14.7% faster)

def test_env_var_does_not_exist_returns_empty_string_by_default():
    # Test that function returns empty string if env var is not set and no default is provided
    if "NOT_EXISTING_ENV2" in os.environ:
        del os.environ["NOT_EXISTING_ENV2"]
    codeflash_output = get_str_env("NOT_EXISTING_ENV2") # 1.34μs -> 1.19μs (12.3% faster)

def test_env_var_value_is_empty_string():
    # Test that function returns empty string if env var is set to empty string
    os.environ["EMPTY_ENV"] = ""
    codeflash_output = get_str_env("EMPTY_ENV", default="default") # 1.68μs -> 1.43μs (17.5% faster)

def test_env_var_value_is_spaces():
    # Test that function strips whitespace from env var value
    os.environ["SPACE_ENV"] = "   abc   "
    codeflash_output = get_str_env("SPACE_ENV") # 1.60μs -> 1.39μs (14.9% faster)

def test_env_var_value_is_only_spaces():
    # Test that function strips env var value that is only whitespace to empty string
    os.environ["ONLY_SPACES_ENV"] = "    "
    codeflash_output = get_str_env("ONLY_SPACES_ENV", default="default") # 1.83μs -> 1.60μs (14.8% faster)

def test_env_var_value_is_numeric():
    # Test that function returns numeric env var value as string
    os.environ["NUMERIC_ENV"] = "12345"
    codeflash_output = get_str_env("NUMERIC_ENV") # 1.46μs -> 1.22μs (19.8% faster)

def test_env_var_value_is_bool_string():
    # Test that function returns boolean-like env var value as string
    os.environ["BOOL_ENV"] = "True"
    codeflash_output = get_str_env("BOOL_ENV") # 1.49μs -> 1.25μs (18.6% faster)

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



def test_env_var_value_is_none():
    # Test that function returns default if env var is set to None (should not happen in os.environ, but test anyway)
    # Remove if exists
    if "NONE_ENV" in os.environ:
        del os.environ["NONE_ENV"]
    codeflash_output = get_str_env("NONE_ENV", default="none") # 2.02μs -> 1.70μs (18.9% faster)

def test_env_var_value_is_multiline():
    # Test that function returns multiline string, with only leading/trailing whitespace stripped
    os.environ["MULTILINE_ENV"] = "\n  line1\nline2  \n"
    codeflash_output = get_str_env("MULTILINE_ENV") # 1.72μs -> 1.43μs (20.5% faster)

def test_env_var_value_is_unicode():
    # Test that function returns unicode env var value
    os.environ["UNICODE_ENV"] = "你好，世界"
    codeflash_output = get_str_env("UNICODE_ENV") # 2.27μs -> 2.10μs (8.49% faster)


def test_env_var_value_is_tabbed():
    # Test that function strips tabs and newlines from both sides
    os.environ["TABBED_ENV"] = "\t\tvalue\t\n"
    codeflash_output = get_str_env("TABBED_ENV") # 2.01μs -> 1.56μs (28.6% faster)

def test_env_var_value_is_very_long_string():
    # Test with a long string (edge of reasonable env var length)
    long_val = "x" * 1000
    os.environ["LONG_ENV"] = "   " + long_val + "   "
    codeflash_output = get_str_env("LONG_ENV") # 2.25μs -> 1.82μs (23.8% faster)

def test_env_var_default_is_empty_string():
    # Test that default of empty string is returned if env var is missing
    if "MISSING_ENV" in os.environ:
        del os.environ["MISSING_ENV"]
    codeflash_output = get_str_env("MISSING_ENV") # 1.38μs -> 1.21μs (13.8% faster)

def test_env_var_default_is_none():
    # Test that default=None is handled (should return None if default is None)
    if "NONE_DEFAULT_ENV" in os.environ:
        del os.environ["NONE_DEFAULT_ENV"]
    codeflash_output = get_str_env("NONE_DEFAULT_ENV", default=None) # 1.74μs -> 1.55μs (12.2% faster)

def test_env_var_value_is_string_with_leading_trailing_newlines():
    # Test that leading/trailing newlines are stripped
    os.environ["NEWLINE_ENV"] = "\n\nsomeval\n\n"
    codeflash_output = get_str_env("NEWLINE_ENV") # 1.66μs -> 1.35μs (23.0% faster)

def test_env_var_value_is_string_with_only_newlines():
    # Test that only newlines are stripped to empty string
    os.environ["ONLY_NEWLINES_ENV"] = "\n\n\n"
    codeflash_output = get_str_env("ONLY_NEWLINES_ENV", default="default") # 1.78μs -> 1.53μs (16.4% faster)

def test_env_var_value_is_bytes():
    # os.environ only allows str, but test that function can handle non-str if injected
    os.environ["BYTES_ENV"] = "abc"  # can't actually set bytes in os.environ
    codeflash_output = get_str_env("BYTES_ENV") # 1.58μs -> 1.26μs (25.2% faster)

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

def test_many_env_vars_set_and_get():
    # Test function with many env vars set and get their values
    N = 500  # not too large for test
    names = [f"ENV_{i}" for i in range(N)]
    for i, name in enumerate(names):
        os.environ[name] = f"value_{i}"
    # Check all values
    for i, name in enumerate(names):
        codeflash_output = get_str_env(name) # 287μs -> 258μs (11.0% faster)

def test_many_env_vars_missing_returns_default():
    # Test function with many missing env vars, all should return default
    N = 500
    names = [f"MISSING_ENV_{i}" for i in range(N)]
    for name in names:
        if name in os.environ:
            del os.environ[name]
    for name in names:
        codeflash_output = get_str_env(name, default="default") # 351μs -> 335μs (4.70% faster)

def test_large_env_var_value():
    # Test with a single very large env var value
    large_val = ''.join(random.choices(string.ascii_letters + string.digits, k=999))
    os.environ["LARGE_ENV_VAR"] = " " * 10 + large_val + " " * 10
    codeflash_output = get_str_env("LARGE_ENV_VAR") # 2.35μs -> 2.07μs (13.7% faster)

def test_large_number_of_env_var_names_with_various_values():
    # Test with a mix of present and missing env vars, various values
    N = 300
    present_names = [f"PRESENT_{i}" for i in range(N)]
    missing_names = [f"MISSING_{i}" for i in range(N)]
    for i, name in enumerate(present_names):
        os.environ[name] = f"val_{i}"
    for name in missing_names:
        if name in os.environ:
            del os.environ[name]
    # Check present
    for i, name in enumerate(present_names):
        codeflash_output = get_str_env(name, default="zzz") # 192μs -> 176μs (8.94% faster)
    # Check missing
    for name in missing_names:
        codeflash_output = get_str_env(name, default="zzz") # 213μs -> 204μs (4.11% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
import os

# imports
import pytest
from src.config.loader import get_str_env

# 1. Basic Test Cases

def test_env_var_exists_returns_value(monkeypatch):
    """Test that the function returns the value of an existing environment variable."""
    monkeypatch.setenv("TEST_VAR", "hello")
    codeflash_output = get_str_env("TEST_VAR") # 1.57μs -> 1.26μs (25.0% faster)

def test_env_var_exists_returns_stripped_value(monkeypatch):
    """Test that the function strips whitespace from the value."""
    monkeypatch.setenv("TEST_VAR", "  hello world  ")
    codeflash_output = get_str_env("TEST_VAR") # 1.62μs -> 1.36μs (18.5% faster)

def test_env_var_not_exists_returns_default(monkeypatch):
    """Test that the function returns the default value when the variable is not set."""
    if "TEST_VAR" in os.environ:
        monkeypatch.delenv("TEST_VAR")
    codeflash_output = get_str_env("TEST_VAR", default="default_value") # 1.68μs -> 1.41μs (19.5% faster)

def test_env_var_not_exists_returns_empty_string(monkeypatch):
    """Test that the function returns empty string when variable is not set and no default is given."""
    if "TEST_VAR" in os.environ:
        monkeypatch.delenv("TEST_VAR")
    codeflash_output = get_str_env("TEST_VAR") # 1.37μs -> 1.12μs (22.5% faster)

def test_env_var_exists_empty_string(monkeypatch):
    """Test that the function returns empty string if the env var is set to empty."""
    monkeypatch.setenv("TEST_VAR", "")
    codeflash_output = get_str_env("TEST_VAR", default="default") # 1.68μs -> 1.36μs (23.5% faster)

def test_env_var_exists_with_only_spaces(monkeypatch):
    """Test that the function strips and returns empty string if env var only contains whitespace."""
    monkeypatch.setenv("TEST_VAR", "    ")
    codeflash_output = get_str_env("TEST_VAR", default="default") # 1.70μs -> 1.46μs (17.0% faster)

def test_env_var_exists_returns_non_string(monkeypatch):
    """Test that the function coerces non-string values to string and strips them."""
    monkeypatch.setenv("TEST_VAR", "12345")
    codeflash_output = get_str_env("TEST_VAR") # 1.55μs -> 1.22μs (27.2% faster)

# 2. Edge Test Cases

def test_env_var_name_case_sensitivity(monkeypatch):
    """Test that environment variable names are case sensitive."""
    monkeypatch.setenv("TEST_VAR", "foo")
    codeflash_output = get_str_env("test_var", default="bar") # 1.67μs -> 1.53μs (8.66% faster)
    codeflash_output = get_str_env("TEST_VAR", default="bar") # 1.25μs -> 961ns (30.5% faster)

def test_env_var_value_is_none(monkeypatch):
    """Test that if the env var is not set, returns default (simulate None)."""
    if "TEST_VAR" in os.environ:
        monkeypatch.delenv("TEST_VAR")
    codeflash_output = get_str_env("TEST_VAR", default="fallback") # 1.65μs -> 1.33μs (24.2% faster)

def test_env_var_value_is_numeric_string(monkeypatch):
    """Test that numeric string values are returned as strings."""
    monkeypatch.setenv("TEST_VAR", "9876543210")
    codeflash_output = get_str_env("TEST_VAR") # 1.44μs -> 1.15μs (24.7% faster)

def test_env_var_value_is_special_characters(monkeypatch):
    """Test that special characters are preserved and stripped correctly."""
    monkeypatch.setenv("TEST_VAR", "  !@#$%^&*()_+-=  ")
    codeflash_output = get_str_env("TEST_VAR") # 1.60μs -> 1.28μs (25.1% faster)

def test_env_var_value_is_multiline(monkeypatch):
    """Test that multiline values are preserved and only leading/trailing whitespace is stripped."""
    monkeypatch.setenv("TEST_VAR", "\n  line1\nline2  \n")
    codeflash_output = get_str_env("TEST_VAR") # 1.59μs -> 1.26μs (26.5% faster)


def test_env_var_name_is_whitespace(monkeypatch):
    """Test that a whitespace-only env var name is handled gracefully."""
    codeflash_output = get_str_env("   ", default="whitespace") # 2.19μs -> 1.91μs (14.8% faster)

def test_env_var_default_is_none(monkeypatch):
    """Test that default=None returns None if the variable is not set."""
    if "TEST_VAR" in os.environ:
        monkeypatch.delenv("TEST_VAR")
    codeflash_output = get_str_env("TEST_VAR", default=None) # 1.55μs -> 1.33μs (15.8% faster)

def test_env_var_value_is_unicode(monkeypatch):
    """Test that unicode characters are preserved and stripped."""
    monkeypatch.setenv("TEST_VAR", "  你好，世界  ")
    codeflash_output = get_str_env("TEST_VAR") # 2.54μs -> 2.36μs (7.50% faster)

def test_env_var_value_is_tab_whitespace(monkeypatch):
    """Test that tab and newline whitespace is stripped."""
    monkeypatch.setenv("TEST_VAR", "\t\tfoo bar\t\n")
    codeflash_output = get_str_env("TEST_VAR") # 1.61μs -> 1.26μs (27.9% faster)

def test_env_var_value_is_only_newlines(monkeypatch):
    """Test that only-newline values are stripped to empty string."""
    monkeypatch.setenv("TEST_VAR", "\n\n\n")
    codeflash_output = get_str_env("TEST_VAR", default="def") # 1.75μs -> 1.36μs (28.8% faster)

def test_env_var_default_is_empty_string(monkeypatch):
    """Test that default empty string is returned if variable is not set."""
    if "TEST_VAR" in os.environ:
        monkeypatch.delenv("TEST_VAR")
    codeflash_output = get_str_env("TEST_VAR", default="") # 1.64μs -> 1.41μs (16.8% faster)

def test_env_var_value_is_boolean_string(monkeypatch):
    """Test that boolean-like string values are returned as is, stripped."""
    monkeypatch.setenv("TEST_VAR", "  True  ")
    codeflash_output = get_str_env("TEST_VAR") # 1.59μs -> 1.28μs (23.9% faster)
    monkeypatch.setenv("TEST_VAR", "False")
    codeflash_output = get_str_env("TEST_VAR") # 963ns -> 858ns (12.2% faster)

# 3. Large Scale Test Cases

def test_many_env_vars(monkeypatch):
    """Test that the function works correctly with a large number of environment variables."""
    for i in range(500):
        monkeypatch.setenv(f"VAR_{i}", f"value_{i}")
    # Check a few random variables
    codeflash_output = get_str_env("VAR_0") # 2.15μs -> 1.67μs (28.4% faster)
    codeflash_output = get_str_env("VAR_123") # 1.09μs -> 925ns (17.7% faster)
    codeflash_output = get_str_env("VAR_499") # 652ns -> 654ns (0.306% slower)
    # Check non-existent variable
    codeflash_output = get_str_env("VAR_999", default="notfound") # 1.29μs -> 1.23μs (4.64% faster)

def test_long_env_var_value(monkeypatch):
    """Test that the function handles very long environment variable values."""
    long_value = "a" * 1000
    monkeypatch.setenv("LONG_VAR", "   " + long_value + "   ")
    codeflash_output = get_str_env("LONG_VAR") # 2.10μs -> 1.82μs (15.0% faster)

def test_env_var_name_and_value_max_length(monkeypatch):
    """Test that the function handles max-length variable names and values."""
    # POSIX does not specify a max env var name length, but some systems limit to 255
    long_name = "V" * 255
    long_value = "X" * 1000
    monkeypatch.setenv(long_name, "   " + long_value + "   ")
    codeflash_output = get_str_env(long_name) # 2.19μs -> 1.97μs (11.4% faster)

def test_env_var_value_with_various_whitespace(monkeypatch):
    """Test that the function strips all types of leading/trailing whitespace in a large value."""
    value = " \t\n\r" + "bigvalue" * 100 + " \n\t\r"
    monkeypatch.setenv("MIXED_WS", value)
    codeflash_output = get_str_env("MIXED_WS") # 1.79μs -> 1.53μs (17.0% faster)

def test_bulk_env_var_access(monkeypatch):
    """Test performance and correctness when accessing many variables in sequence."""
    for i in range(1000):
        monkeypatch.setenv(f"KEY_{i}", f"VAL_{i}")
    # Check all values
    for i in range(1000):
        codeflash_output = get_str_env(f"KEY_{i}") # 581μs -> 525μs (10.7% faster)
    # Check a missing one
    codeflash_output = get_str_env("KEY_1001", default="missing") # 1.98μs -> 1.86μs (6.55% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from src.config.loader import get_str_env

def test_get_str_env():
    get_str_env('_', default='')

def test_get_str_env_2():
    get_str_env('', default='')

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_0_gkn0tr/tmp_hkxhbtt/test_concolic_coverage.py::test_get_str_env	1.86μs	1.50μs	24.1%✅
codeflash_concolic_0_gkn0tr/tmp_hkxhbtt/test_concolic_coverage.py::test_get_str_env_2	1.97μs	1.77μs	11.7%✅

To edit these changes git checkout codeflash/optimize-get_str_env-mgv157zv and push.