⚡️ Speed up method InferenceConfig._get_float by 9%

[codeflash-ai]

📄 9% (0.09x) speedup for InferenceConfig._get_float in unstructured_inference/config.py

⏱️ Runtime : 589 microseconds → 539 microseconds (best of 163 runs)

📝 Explanation and details

The optimization eliminates the intermediate method call to _get_string() by inlining the environment variable lookup directly in _get_float().

What changed:

• Replaced self._get_string(var) with os.environ.get(var, "")
• This removes one layer of function call indirection

Why it's faster:
In Python, function calls carry overhead including stack frame creation, argument passing, and return value handling. The line profiler shows that in the original code, the self._get_string(var) call consumed 94.6% of _get_float's total time (3.63ms out of 3.84ms). By inlining the single-line os.environ.get() operation, we eliminate this per-call overhead entirely.

The optimization delivers consistent ~6-17% speedups across test cases, with the largest gains (13-17%) appearing when environment variables are missing or empty strings—precisely the cases where the method call overhead dominated the total work. Even tests that parse valid floats see 5-11% improvements.

Impact on workloads:
Since _get_float() is a utility method for reading configuration from environment variables, this optimization benefits any code path that reads multiple float configs at startup or during runtime reconfiguration. The 9% average speedup compounds when called repeatedly (as shown in the large-scale test with 500 iterations gaining 8% speedup), making initialization and config-heavy code paths measurably faster while maintaining identical behavior including exception handling.

✅ Correctness verification report:

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

🌀 Click to see Generated Regression Tests

import math  # used to test NaN/Inf behavior
# imports
import os  # used to inspect environment variables in assertions when helpful
from dataclasses import \
    dataclass  # required to define the original class exactly

import pytest  # used for our unit tests
from unstructured_inference.config import InferenceConfig

def test_basic_parses_decimal_string(monkeypatch):
    # Arrange: set an environment variable to a simple decimal string
    monkeypatch.setenv("TEST_DECIMAL", "3.14")
    cfg = InferenceConfig()  # instantiate the config object

    # Act: retrieve the float from the env var with a different default
    codeflash_output = cfg._get_float("TEST_DECIMAL", 0.0); result = codeflash_output # 3.12μs -> 2.87μs (8.64% faster)

def test_returns_default_when_env_missing(monkeypatch):
    # Arrange: ensure the environment variable is not present
    monkeypatch.delenv("MISSING_VAR", raising=False)
    cfg = InferenceConfig()

    # Act: attempt to get a float where the env var is absent
    default_value = 7.25
    codeflash_output = cfg._get_float("MISSING_VAR", default_value); result = codeflash_output # 2.81μs -> 2.51μs (11.9% faster)

def test_empty_string_env_returns_default(monkeypatch):
    # Arrange: set the environment variable to an empty string (falsy)
    # According to the implementation, empty string yields default because assignment tests truthiness
    monkeypatch.setenv("EMPTY_VAR", "")
    cfg = InferenceConfig()

    # Act: call the method with an explicit default
    default_value = -1.0
    codeflash_output = cfg._get_float("EMPTY_VAR", default_value); result = codeflash_output # 2.40μs -> 2.05μs (16.8% faster)

def test_invalid_numeric_string_raises_value_error(monkeypatch):
    # Arrange: set env var to a non-numeric string that float() cannot parse
    monkeypatch.setenv("INVALID_NUM", "not_a_number")
    cfg = InferenceConfig()

    # Act / Assert: the function should propagate the ValueError raised by float()
    with pytest.raises(ValueError):
        cfg._get_float("INVALID_NUM", 0.0) # 4.94μs -> 4.75μs (3.89% faster)

def test_scientific_and_signed_notation(monkeypatch):
    cfg = InferenceConfig()

    # scientific notation
    monkeypatch.setenv("SCI_VAR", "1e3")
    codeflash_output = cfg._get_float("SCI_VAR", 0.0) # 3.29μs -> 2.96μs (11.4% faster)

    # negative numbers
    monkeypatch.setenv("NEG_VAR", "-5.5")
    codeflash_output = cfg._get_float("NEG_VAR", 0.0) # 1.81μs -> 1.70μs (6.05% faster)

    # explicit plus sign
    monkeypatch.setenv("PLUS_VAR", "+4.2")
    codeflash_output = cfg._get_float("PLUS_VAR", 0.0) # 1.45μs -> 1.37μs (5.32% faster)

def test_nan_and_infinite_values(monkeypatch):
    cfg = InferenceConfig()

    # NaN should be returned as float('nan') and be detectable via math.isnan
    monkeypatch.setenv("NAN_VAR", "nan")
    codeflash_output = cfg._get_float("NAN_VAR", 0.0); nan_result = codeflash_output # 3.19μs -> 2.94μs (8.22% faster)

    # Very large exponent leads to infinity (no exception), which math.isinf detects
    monkeypatch.setenv("INF_VAR", "1e309")  # larger than double range -> inf
    codeflash_output = cfg._get_float("INF_VAR", 0.0); inf_result = codeflash_output # 2.02μs -> 1.96μs (2.75% faster)

def test_default_type_preserved_when_missing(monkeypatch):
    # Arrange: ensure env var not present and pass an integer default
    monkeypatch.delenv("MISSING_TYPE_VAR", raising=False)
    cfg = InferenceConfig()

    # Act: call with an int default even though signature says float; function should return it unchanged
    default_int = 42  # intentionally an int
    codeflash_output = cfg._get_float("MISSING_TYPE_VAR", default_int); result = codeflash_output # 2.74μs -> 2.41μs (13.7% faster)

def test_integer_string_converts_to_float(monkeypatch):
    # Arrange: integer string should convert to a float (2 -> 2.0)
    monkeypatch.setenv("INT_STR_VAR", "2")
    cfg = InferenceConfig()

    # Act
    codeflash_output = cfg._get_float("INT_STR_VAR", 0.5); result = codeflash_output # 3.17μs -> 2.80μs (13.2% faster)

def test_large_scale_many_env_vars(monkeypatch):
    # Large-scale test: create a sizable but bounded set of environment variables and validate conversions.
    # We avoid loops > 1000 iterations and keep count at 500 to check scalability without undue runtime.
    cfg = InferenceConfig()
    n = 500  # within the allowed maximum per instructions

    # Populate environment variables with predictable float strings
    for i in range(n):
        # each env var holds a distinct float value to validate mapping and parsing under load
        monkeypatch.setenv(f"LARGE_VAR_{i}", str(i + 0.5))

    # Validate a sample of values (not necessarily all) to keep runtime reasonable while
    # ensuring that the implementation handles many env vars populated.
    # Check first, middle, and last indices to exercise different locations.
    samples = [0, n // 2, n - 1]
    for idx in samples:
        varname = f"LARGE_VAR_{idx}"
        expected = float(idx + 0.5)
        codeflash_output = cfg._get_float(varname, -1.0); result = codeflash_output # 7.01μs -> 6.48μs (8.16% faster)

    # Also verify that an unrelated missing variable still returns its default after many env ops
    monkeypatch.delenv("LARGE_VAR_MISSING", raising=False)
    codeflash_output = cfg._get_float("LARGE_VAR_MISSING", 999.0) # 1.57μs -> 1.45μs (8.51% 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

import pytest
from unstructured_inference.config import InferenceConfig

class TestInferenceConfigGetFloat:
    """Test suite for InferenceConfig._get_float method"""

    # Basic Test Cases
    # ================

    def test_get_float_with_valid_integer_string(self):
        """Test that _get_float correctly converts a valid integer string from environment"""
        config = InferenceConfig()
        os.environ['TEST_INT_VAR'] = '42'
        try:
            codeflash_output = config._get_float('TEST_INT_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['TEST_INT_VAR']

    def test_get_float_with_valid_float_string(self):
        """Test that _get_float correctly converts a valid float string from environment"""
        config = InferenceConfig()
        os.environ['TEST_FLOAT_VAR'] = '3.14159'
        try:
            codeflash_output = config._get_float('TEST_FLOAT_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['TEST_FLOAT_VAR']

    def test_get_float_with_missing_env_var_returns_default(self):
        """Test that _get_float returns default value when environment variable is not set"""
        config = InferenceConfig()
        # Ensure the variable doesn't exist
        if 'NONEXISTENT_VAR' in os.environ:
            del os.environ['NONEXISTENT_VAR']
        codeflash_output = config._get_float('NONEXISTENT_VAR', 99.5); result = codeflash_output # 2.81μs -> 2.50μs (12.5% faster)

    def test_get_float_with_default_value_zero(self):
        """Test that _get_float works correctly with a default value of 0.0"""
        config = InferenceConfig()
        if 'MISSING_VAR' in os.environ:
            del os.environ['MISSING_VAR']
        codeflash_output = config._get_float('MISSING_VAR', 0.0); result = codeflash_output # 2.76μs -> 2.46μs (12.2% faster)

    def test_get_float_with_positive_float(self):
        """Test that _get_float correctly handles positive float values"""
        config = InferenceConfig()
        os.environ['POSITIVE_VAR'] = '123.456'
        try:
            codeflash_output = config._get_float('POSITIVE_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['POSITIVE_VAR']

    def test_get_float_with_negative_float(self):
        """Test that _get_float correctly handles negative float values"""
        config = InferenceConfig()
        os.environ['NEGATIVE_VAR'] = '-45.67'
        try:
            codeflash_output = config._get_float('NEGATIVE_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['NEGATIVE_VAR']

    # Edge Test Cases
    # ===============

    def test_get_float_with_zero_string(self):
        """Test that _get_float correctly converts string '0' to float 0.0"""
        config = InferenceConfig()
        os.environ['ZERO_VAR'] = '0'
        try:
            codeflash_output = config._get_float('ZERO_VAR', 99.0); result = codeflash_output
        finally:
            del os.environ['ZERO_VAR']

    def test_get_float_with_zero_float_string(self):
        """Test that _get_float correctly converts string '0.0' to float 0.0"""
        config = InferenceConfig()
        os.environ['ZERO_FLOAT_VAR'] = '0.0'
        try:
            codeflash_output = config._get_float('ZERO_FLOAT_VAR', 99.0); result = codeflash_output
        finally:
            del os.environ['ZERO_FLOAT_VAR']

    def test_get_float_with_very_small_positive_float(self):
        """Test that _get_float handles very small positive floating point numbers"""
        config = InferenceConfig()
        os.environ['SMALL_FLOAT_VAR'] = '0.00000001'
        try:
            codeflash_output = config._get_float('SMALL_FLOAT_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['SMALL_FLOAT_VAR']

    def test_get_float_with_very_large_float(self):
        """Test that _get_float handles very large floating point numbers"""
        config = InferenceConfig()
        os.environ['LARGE_FLOAT_VAR'] = '999999999.999999'
        try:
            codeflash_output = config._get_float('LARGE_FLOAT_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['LARGE_FLOAT_VAR']

    def test_get_float_with_scientific_notation(self):
        """Test that _get_float correctly handles scientific notation"""
        config = InferenceConfig()
        os.environ['SCI_VAR'] = '1.23e-4'
        try:
            codeflash_output = config._get_float('SCI_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['SCI_VAR']

    def test_get_float_with_negative_scientific_notation(self):
        """Test that _get_float correctly handles negative scientific notation"""
        config = InferenceConfig()
        os.environ['NEG_SCI_VAR'] = '-5.67e-3'
        try:
            codeflash_output = config._get_float('NEG_SCI_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['NEG_SCI_VAR']

    def test_get_float_with_empty_string_uses_default(self):
        """Test that _get_float returns default when environment variable is empty string"""
        config = InferenceConfig()
        os.environ['EMPTY_VAR'] = ''
        try:
            codeflash_output = config._get_float('EMPTY_VAR', 42.5); result = codeflash_output
        finally:
            del os.environ['EMPTY_VAR']

    def test_get_float_with_whitespace_only_string(self):
        """Test that _get_float handles whitespace-only environment variable"""
        config = InferenceConfig()
        os.environ['WHITESPACE_VAR'] = '   '
        try:
            # Whitespace string is truthy, so float() will be called on it
            # float() in Python can handle leading/trailing whitespace
            codeflash_output = config._get_float('WHITESPACE_VAR', 10.0); result = codeflash_output
        except ValueError:
            # If float() raises ValueError for whitespace, that's also valid behavior
            pass
        finally:
            del os.environ['WHITESPACE_VAR']

    def test_get_float_with_leading_whitespace(self):
        """Test that _get_float correctly handles float string with leading whitespace"""
        config = InferenceConfig()
        os.environ['LEADING_WS_VAR'] = '  42.5'
        try:
            # Python's float() handles leading whitespace
            codeflash_output = config._get_float('LEADING_WS_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['LEADING_WS_VAR']

    def test_get_float_with_trailing_whitespace(self):
        """Test that _get_float correctly handles float string with trailing whitespace"""
        config = InferenceConfig()
        os.environ['TRAILING_WS_VAR'] = '42.5  '
        try:
            # Python's float() handles trailing whitespace
            codeflash_output = config._get_float('TRAILING_WS_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['TRAILING_WS_VAR']

    def test_get_float_with_positive_sign(self):
        """Test that _get_float correctly handles explicit positive sign"""
        config = InferenceConfig()
        os.environ['PLUS_SIGN_VAR'] = '+123.45'
        try:
            codeflash_output = config._get_float('PLUS_SIGN_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['PLUS_SIGN_VAR']

    def test_get_float_invalid_string_raises_valueerror(self):
        """Test that _get_float raises ValueError for non-numeric string"""
        config = InferenceConfig()
        os.environ['INVALID_VAR'] = 'not_a_number'
        try:
            with pytest.raises(ValueError):
                config._get_float('INVALID_VAR', 0.0)
        finally:
            del os.environ['INVALID_VAR']

    def test_get_float_with_special_characters_raises_valueerror(self):
        """Test that _get_float raises ValueError when value contains special characters"""
        config = InferenceConfig()
        os.environ['SPECIAL_VAR'] = '123.45@'
        try:
            with pytest.raises(ValueError):
                config._get_float('SPECIAL_VAR', 0.0)
        finally:
            del os.environ['SPECIAL_VAR']

    def test_get_float_with_multiple_decimal_points_raises_valueerror(self):
        """Test that _get_float raises ValueError when value has multiple decimal points"""
        config = InferenceConfig()
        os.environ['MULTI_DOT_VAR'] = '123.45.67'
        try:
            with pytest.raises(ValueError):
                config._get_float('MULTI_DOT_VAR', 0.0)
        finally:
            del os.environ['MULTI_DOT_VAR']

    def test_get_float_with_infinity_string(self):
        """Test that _get_float correctly handles 'inf' string"""
        config = InferenceConfig()
        os.environ['INF_VAR'] = 'inf'
        try:
            codeflash_output = config._get_float('INF_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['INF_VAR']

    def test_get_float_with_negative_infinity_string(self):
        """Test that _get_float correctly handles '-inf' string"""
        config = InferenceConfig()
        os.environ['NEG_INF_VAR'] = '-inf'
        try:
            codeflash_output = config._get_float('NEG_INF_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['NEG_INF_VAR']

    def test_get_float_with_nan_string(self):
        """Test that _get_float correctly handles 'nan' string"""
        config = InferenceConfig()
        os.environ['NAN_VAR'] = 'nan'
        try:
            codeflash_output = config._get_float('NAN_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['NAN_VAR']

    def test_get_float_preserves_precision(self):
        """Test that _get_float preserves floating point precision appropriately"""
        config = InferenceConfig()
        os.environ['PRECISION_VAR'] = '0.123456789'
        try:
            codeflash_output = config._get_float('PRECISION_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['PRECISION_VAR']

    # Large Scale Test Cases
    # ======================

    def test_get_float_with_many_sequential_calls(self):
        """Test that _get_float works correctly with many sequential calls to different variables"""
        config = InferenceConfig()
        num_vars = 100
        
        # Set up multiple environment variables
        var_names = [f'VAR_{i}' for i in range(num_vars)]
        values = [float(i) * 1.5 for i in range(num_vars)]
        
        for var_name, value in zip(var_names, values):
            os.environ[var_name] = str(value)
        
        try:
            # Call _get_float for each variable and verify results
            for var_name, expected_value in zip(var_names, values):
                codeflash_output = config._get_float(var_name, 0.0); result = codeflash_output
        finally:
            # Clean up all environment variables
            for var_name in var_names:
                del os.environ[var_name]

    def test_get_float_performance_with_large_precision_numbers(self):
        """Test that _get_float efficiently handles numbers with high precision"""
        config = InferenceConfig()
        # Create a number with many decimal places
        large_precision_str = '3.' + '1' * 200
        os.environ['LARGE_PRECISION_VAR'] = large_precision_str
        
        try:
            codeflash_output = config._get_float('LARGE_PRECISION_VAR', 0.0); result = codeflash_output
        finally:
            del os.environ['LARGE_PRECISION_VAR']

    def test_get_float_with_repeated_default_fallback(self):
        """Test that _get_float correctly returns default value in 100 consecutive missing calls"""
        config = InferenceConfig()
        default_values = [i * 0.5 for i in range(100)]
        
        # Ensure all variables don't exist
        for i in range(100):
            if f'MISSING_{i}' in os.environ:
                del os.environ[f'MISSING_{i}']
        
        # Call _get_float with missing variables
        for i, default_val in enumerate(default_values):
            codeflash_output = config._get_float(f'MISSING_{i}', default_val); result = codeflash_output # 141μs -> 130μs (8.73% faster)

    def test_get_float_with_mixed_variable_types(self):
        """Test that _get_float correctly handles a mix of integers, floats, and scientific notation"""
        config = InferenceConfig()
        test_cases = [
            ('INT_VAR', '42', 42.0),
            ('FLOAT_VAR', '3.14', 3.14),
            ('SCI_VAR', '1e3', 1000.0),
            ('NEG_VAR', '-99.5', -99.5),
            ('SMALL_VAR', '0.001', 0.001),
        ]
        
        for var_name, var_value, expected in test_cases:
            os.environ[var_name] = var_value
        
        try:
            for var_name, _, expected in test_cases:
                codeflash_output = config._get_float(var_name, 0.0); result = codeflash_output
        finally:
            for var_name, _, _ in test_cases:
                del os.environ[var_name]

    def test_get_float_default_value_range(self):
        """Test that _get_float correctly returns various default values from a large range"""
        config = InferenceConfig()
        default_values = [float(i) - 50.0 for i in range(100)]
        
        for i in range(100):
            if f'MISSING_VAR_{i}' in os.environ:
                del os.environ[f'MISSING_VAR_{i}']
        
        # Test with various default values
        for i, default_val in enumerate(default_values):
            codeflash_output = config._get_float(f'MISSING_VAR_{i}', default_val); result = codeflash_output # 141μs -> 130μs (8.53% faster)

    def test_get_float_multiple_instances(self):
        """Test that multiple InferenceConfig instances work independently"""
        config1 = InferenceConfig()
        config2 = InferenceConfig()
        
        os.environ['SHARED_VAR'] = '42.5'
        
        try:
            codeflash_output = config1._get_float('SHARED_VAR', 0.0); result1 = codeflash_output
            codeflash_output = config2._get_float('SHARED_VAR', 0.0); result2 = codeflash_output
        finally:
            del os.environ['SHARED_VAR']

    def test_get_float_env_var_update_reflected(self):
        """Test that _get_float reflects environment variable updates"""
        config = InferenceConfig()
        
        # Set initial value
        os.environ['DYNAMIC_VAR'] = '10.5'
        codeflash_output = config._get_float('DYNAMIC_VAR', 0.0); result1 = codeflash_output # 3.26μs -> 2.90μs (12.4% faster)
        
        # Update the value
        os.environ['DYNAMIC_VAR'] = '20.5'
        codeflash_output = config._get_float('DYNAMIC_VAR', 0.0); result2 = codeflash_output # 1.65μs -> 1.54μs (6.82% faster)
        
        # Clean up
        del os.environ['DYNAMIC_VAR']

    def test_get_float_boundary_values(self):
        """Test that _get_float correctly handles various boundary value floats"""
        config = InferenceConfig()
        boundary_values = [
            '0.0',
            '1.0',
            '-1.0',
            '0.1',
            '-0.1',
            '1e-10',
            '-1e-10',
            '1e10',
            '-1e10',
        ]
        
        for i, val_str in enumerate(boundary_values):
            var_name = f'BOUNDARY_{i}'
            os.environ[var_name] = val_str
        
        try:
            for i, val_str in enumerate(boundary_values):
                var_name = f'BOUNDARY_{i}'
                codeflash_output = config._get_float(var_name, 0.0); result = codeflash_output
                expected = float(val_str)
        finally:
            for i in range(len(boundary_values)):
                if f'BOUNDARY_{i}' in os.environ:
                    del os.environ[f'BOUNDARY_{i}']
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from unstructured_inference.config import InferenceConfig
import pytest

def test_InferenceConfig__get_float():
    with pytest.raises(ValueError, match="could\\ not\\ convert\\ string\\ to\\ float:\\ '/home/aseem/cf\\-unstr/unstructured\\-inference/\\.venv/bin/codeflash'"):
        InferenceConfig._get_float(InferenceConfig(), '_', 0.0)

def test_InferenceConfig__get_float_2():
    InferenceConfig._get_float(InferenceConfig(), '', 0.0)

🔎 Click to see Concolic Coverage Tests

Test File::Test Function	Original ⏱️	Optimized ⏱️	Speedup
codeflash_concolic_toh405kj/tmpvuaki8u8/test_concolic_coverage.py::test_InferenceConfig__get_float	5.89μs	5.67μs	3.97%✅
codeflash_concolic_toh405kj/tmpvuaki8u8/test_concolic_coverage.py::test_InferenceConfig__get_float_2	3.90μs	3.51μs	11.3%✅

To edit these changes git checkout codeflash/optimize-InferenceConfig._get_float-mkowr6k2 and push.