⚡️ Speed up method Config._perform_cast by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for Config._perform_cast in starlette/config.py

⏱️ Runtime : 1.36 milliseconds → 1.24 milliseconds (best of 44 runs)

📝 Explanation and details

The optimization replaces dictionary-based boolean mapping with direct string comparisons, eliminating repeated dictionary creation and reducing method calls.

Key changes:

• Removed dictionary allocation: The mapping = {"true": True, "1": True, "false": False, "0": False} dictionary is no longer created on every boolean cast call
• Eliminated dictionary lookup: Instead of mapping[value], the code now uses direct string comparisons with if/elif branches
• Reduced method calls: The value not in mapping check is replaced with explicit equality comparisons

Why this is faster:

• Dictionary creation ({}) has allocation overhead that occurs on every boolean cast
• Dictionary lookups involve hash computation and collision handling
• Direct string equality (==) is faster than dictionary membership testing (in) followed by key lookup
• The branch-based approach has better cache locality for the common true/false cases

Performance gains by test type:

• Boolean string casting: 24-59% faster (most significant gains) - directly benefits from eliminated dictionary operations
• Other casting operations: 0-8% faster - benefits from reduced overall method overhead
• Large-scale boolean operations: 44.5% faster - compound benefits when processing many boolean values

The optimization is particularly effective for boolean conversions while maintaining identical behavior and error handling for all other cast types.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import os
import warnings
from collections.abc import Mapping
from pathlib import Path
from typing import Any, Callable, TypeVar, overload

# imports
import pytest  # used for our unit tests
from starlette.config import Config


# Dummy environ for completeness
class Environ(dict):
    pass

environ = Environ()
from starlette.config import Config

# unit tests

@pytest.fixture
def config():
    # Provide a Config instance for testing
    return Config()

# 1. Basic Test Cases

def test_perform_cast_none_cast_returns_value(config):
    # Should return value unchanged if cast is None
    codeflash_output = config._perform_cast("FOO", "bar", None) # 576ns -> 529ns (8.88% faster)

def test_perform_cast_none_value_returns_none(config):
    # Should return None if value is None, regardless of cast
    codeflash_output = config._perform_cast("FOO", None, str) # 509ns -> 505ns (0.792% faster)

def test_perform_cast_str_to_int_success(config):
    # Should cast string to int correctly
    codeflash_output = config._perform_cast("FOO", "123", int) # 838ns -> 782ns (7.16% faster)

def test_perform_cast_str_to_float_success(config):
    # Should cast string to float correctly
    codeflash_output = config._perform_cast("FOO", "1.23", float) # 1.16μs -> 1.17μs (0.172% slower)

def test_perform_cast_str_to_bool_true(config):
    # Should cast string "true" to True
    codeflash_output = config._perform_cast("FOO", "true", bool) # 1.67μs -> 1.13μs (47.9% faster)
    # Should cast string "1" to True
    codeflash_output = config._perform_cast("FOO", "1", bool) # 652ns -> 465ns (40.2% faster)

def test_perform_cast_str_to_bool_false(config):
    # Should cast string "false" to False
    codeflash_output = config._perform_cast("FOO", "false", bool) # 1.42μs -> 996ns (42.7% faster)
    # Should cast string "0" to False
    codeflash_output = config._perform_cast("FOO", "0", bool) # 669ns -> 537ns (24.6% faster)

def test_perform_cast_str_to_str(config):
    # Should cast string to string (identity)
    codeflash_output = config._perform_cast("FOO", "baz", str) # 685ns -> 698ns (1.86% slower)

def test_perform_cast_int_to_str(config):
    # Should cast int to string
    codeflash_output = config._perform_cast("FOO", 123, str) # 745ns -> 740ns (0.676% faster)

def test_perform_cast_float_to_int(config):
    # Should cast float to int (truncates)
    codeflash_output = config._perform_cast("FOO", 4.9, int) # 689ns -> 668ns (3.14% faster)

def test_perform_cast_custom_callable(config):
    # Should use custom callable for casting
    def reverse_string(val):
        return val[::-1]
    codeflash_output = config._perform_cast("FOO", "abcd", reverse_string) # 1.17μs -> 1.14μs (2.37% faster)

# 2. Edge Test Cases

def test_perform_cast_bool_invalid_string(config):
    # Should raise ValueError for invalid bool string
    with pytest.raises(ValueError) as excinfo:
        config._perform_cast("FOO", "yes", bool) # 2.03μs -> 1.71μs (18.3% faster)

def test_perform_cast_bool_case_insensitive(config):
    # Should be case-insensitive for bool casting
    codeflash_output = config._perform_cast("FOO", "TRUE", bool) # 1.56μs -> 1.05μs (48.0% faster)
    codeflash_output = config._perform_cast("FOO", "False", bool) # 768ns -> 566ns (35.7% faster)

def test_perform_cast_int_invalid_string(config):
    # Should raise ValueError for invalid int string
    with pytest.raises(ValueError) as excinfo:
        config._perform_cast("FOO", "abc", int) # 4.05μs -> 3.93μs (2.87% faster)

def test_perform_cast_float_invalid_string(config):
    # Should raise ValueError for invalid float string
    with pytest.raises(ValueError) as excinfo:
        config._perform_cast("FOO", "not_a_float", float) # 3.00μs -> 2.94μs (2.11% faster)

def test_perform_cast_callable_raises(config):
    # Should raise ValueError if custom callable raises TypeError
    def always_fail(val):
        raise TypeError("fail")
    with pytest.raises(ValueError) as excinfo:
        config._perform_cast("FOO", "bar", always_fail) # 2.23μs -> 2.29μs (2.58% slower)


def test_perform_cast_bool_with_numeric_string(config):
    # Should handle numeric string for bool
    codeflash_output = config._perform_cast("FOO", "1", bool) # 1.91μs -> 1.26μs (51.4% faster)
    codeflash_output = config._perform_cast("FOO", "0", bool) # 719ns -> 452ns (59.1% faster)

def test_perform_cast_none_value_with_bool(config):
    # Should return None if value is None even with bool cast
    codeflash_output = config._perform_cast("FOO", None, bool) # 470ns -> 451ns (4.21% faster)

def test_perform_cast_empty_string_to_int(config):
    # Should raise ValueError for empty string to int
    with pytest.raises(ValueError):
        config._perform_cast("FOO", "", int) # 4.04μs -> 3.91μs (3.24% faster)

def test_perform_cast_empty_string_to_bool(config):
    # Should raise ValueError for empty string to bool
    with pytest.raises(ValueError):
        config._perform_cast("FOO", "", bool) # 2.00μs -> 1.78μs (12.4% faster)

def test_perform_cast_bool_with_non_string(config):
    # Should cast non-string value with bool cast using Python's bool()
    codeflash_output = config._perform_cast("FOO", 0, bool) # 892ns -> 949ns (6.01% slower)
    codeflash_output = config._perform_cast("FOO", 1, bool) # 485ns -> 443ns (9.48% faster)
    codeflash_output = config._perform_cast("FOO", [], bool) # 412ns -> 268ns (53.7% faster)
    codeflash_output = config._perform_cast("FOO", [1], bool) # 267ns -> 240ns (11.2% faster)

def test_perform_cast_int_to_bool(config):
    # Should cast int to bool using Python's bool()
    codeflash_output = config._perform_cast("FOO", 0, bool) # 795ns -> 756ns (5.16% faster)
    codeflash_output = config._perform_cast("FOO", 2, bool) # 438ns -> 403ns (8.68% faster)

def test_perform_cast_float_to_bool(config):
    # Should cast float to bool using Python's bool()
    codeflash_output = config._perform_cast("FOO", 0.0, bool) # 695ns -> 652ns (6.60% faster)
    codeflash_output = config._perform_cast("FOO", 1.5, bool) # 415ns -> 397ns (4.53% faster)

def test_perform_cast_str_to_bool_nonstandard(config):
    # Should raise ValueError for nonstandard bool string
    with pytest.raises(ValueError):
        config._perform_cast("FOO", "yes", bool) # 1.99μs -> 1.64μs (21.7% faster)

def test_perform_cast_str_to_bool_partial_match(config):
    # Should raise ValueError for partial matches
    with pytest.raises(ValueError):
        config._perform_cast("FOO", "tru", bool) # 1.95μs -> 1.63μs (19.2% faster)
    with pytest.raises(ValueError):
        config._perform_cast("FOO", "fal", bool) # 996ns -> 815ns (22.2% faster)

def test_perform_cast_str_to_float_with_spaces(config):
    # Should cast string with spaces to float
    codeflash_output = config._perform_cast("FOO", "  2.5  ", float) # 1.24μs -> 1.20μs (3.34% faster)

# 3. Large Scale Test Cases

def test_perform_cast_large_list_str_to_int(config):
    # Should cast a large list of string numbers to ints
    str_numbers = [str(i) for i in range(1000)]
    for idx, val in enumerate(str_numbers):
        codeflash_output = config._perform_cast(f"KEY{idx}", val, int) # 226μs -> 224μs (1.18% faster)

def test_perform_cast_large_list_str_to_bool(config):
    # Should cast a large list of "true"/"false" strings to bools
    bool_strs = ["true" if i % 2 == 0 else "false" for i in range(1000)]
    for idx, val in enumerate(bool_strs):
        expected = True if idx % 2 == 0 else False
        codeflash_output = config._perform_cast(f"KEY{idx}", val, bool) # 369μs -> 255μs (44.5% faster)

def test_perform_cast_large_list_float_to_int(config):
    # Should cast a large list of floats to ints
    floats = [float(i) + 0.5 for i in range(1000)]
    for idx, val in enumerate(floats):
        codeflash_output = config._perform_cast(f"KEY{idx}", val, int) # 197μs -> 200μs (1.53% slower)

def test_perform_cast_large_list_str_to_float(config):
    # Should cast a large list of string floats to floats
    str_floats = [str(i + 0.25) for i in range(1000)]
    for idx, val in enumerate(str_floats):
        codeflash_output = config._perform_cast(f"KEY{idx}", val, float) # 227μs -> 226μs (0.452% faster)

def test_perform_cast_large_list_custom_callable(config):
    # Should apply a custom callable to a large list
    def add_prefix(val):
        return "prefix_" + str(val)
    for idx in range(1000):
        codeflash_output = config._perform_cast(f"KEY{idx}", idx, add_prefix) # 293μs -> 297μs (1.24% slower)
# 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, Callable

# imports
import pytest  # used for our unit tests
from starlette.config import Config


def _perform_cast(
    key: str,
    value: Any,
    cast: Callable[[Any], Any] | None = None,
) -> Any:
    if cast is None or value is None:
        return value
    elif cast is bool and isinstance(value, str):
        mapping = {"true": True, "1": True, "false": False, "0": False}
        value_lower = value.lower()
        if value_lower not in mapping:
            raise ValueError(f"Config '{key}' has value '{value}'. Not a valid bool.")
        return mapping[value_lower]
    try:
        return cast(value)
    except (TypeError, ValueError):
        raise ValueError(f"Config '{key}' has value '{value}'. Not a valid {cast.__name__}.")

# unit tests

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





























#------------------------------------------------
from starlette.config import Config

def test_Config__perform_cast():
    Config._perform_cast(Config(env_file=None, environ={}, env_prefix='', encoding=''), '', '', cast=lambda *a: 0)

def test_Config__perform_cast_2():
    Config._perform_cast(Config(env_file='', environ={}, env_prefix='', encoding=''), '', '', cast=None)

🔎 Concolic Coverage Tests and Runtime

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_xzaz2m9_/tmp1uu6n2ey/test_concolic_coverage.py::test_Config__perform_cast	1.21μs	1.18μs	2.03%✅

To edit these changes git checkout codeflash/optimize-Config._perform_cast-mhbhoyz5 and push.