⚡️ Speed up method EnvironmentReader.bool by 32%

[codeflash-ai]

📄 32% (0.32x) speedup for EnvironmentReader.bool in graphrag/config/environment_reader.py

⏱️ Runtime : 660 microseconds → 500 microseconds (best of 133 runs)

📝 Explanation and details

The optimized code achieves a 32% speedup through several key performance improvements:

1. Optimized Type Checking in read_key
The original code checked if not isinstance(value, str) first, which requires evaluating the boolean negation. The optimized version checks if isinstance(value, str) first, which is more direct and handles the common case (string keys) faster. This shows a 9% reduction in per-hit time for string values.

2. Eliminated List Creation in _read_env
The original code converted single strings to lists (env_key = [env_key]), creating unnecessary objects. The optimized version uses a tuple when needed (keys = (env_key,) if isinstance(env_key, str) else env_key), which is more memory-efficient and faster to create. This reduces the function's total time by ~20%.

3. Reduced Attribute Access in bool Method
The original code accessed self.section twice in the conditional check. The optimized version caches it with section = getattr(self, 'section', None) and performs a single lookup, reducing redundant attribute access overhead.

4. Eliminated Lambda Overhead
The original code used lambda k, dv: self._env.bool(k, dv) which adds function call overhead. The optimized version passes self._env.bool directly, removing the lambda wrapper and reducing call stack depth.

Performance Impact by Test Type:

• Small-scale tests: 1-13% improvements due to reduced overhead
• Large-scale tests with long env_key lists: 37-47% improvements, where the tuple optimization and direct callable really shine
• Section-based lookups: 7-28% improvements from cached attribute access

The optimizations are particularly effective for workloads with large environment key lists or frequent attribute access patterns, as evidenced by the substantial gains in the large-scale test cases.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from collections.abc import Callable
from enum import Enum
from typing import TypeVar

# imports
import pytest  # used for our unit tests
from environs import Env
from graphrag.config.environment_reader import EnvironmentReader

# unit tests

# --- Test helpers and fakes ---

class FakeEnv:
    """
    A fake Env object that mimics the interface of environs.Env for .bool().
    """
    def __init__(self, mapping=None):
        self.mapping = mapping or {}

    def bool(self, key, default=None):
        # Simulate environs.Env.bool() behavior: raises if key not found and no default
        key = key.upper()
        if key in self.mapping:
            return self.mapping[key]
        if default is not None:
            return default
        raise KeyError(f"Key {key} not found and no default provided.")

class Color(Enum):
    RED = "RED"
    GREEN = "GREEN"

# --- Basic Test Cases ---

def test_bool_returns_true_for_true_env_value():
    # Basic: key present and True
    env = FakeEnv({"FOO": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo") # 3.41μs -> 3.36μs (1.55% faster)

def test_bool_returns_false_for_false_env_value():
    # Basic: key present and False
    env = FakeEnv({"BAR": False})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("bar") # 2.78μs -> 2.74μs (1.50% faster)

def test_bool_returns_default_when_key_missing():
    # Basic: key missing, default provided
    env = FakeEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("baz", default_value=True) # 2.86μs -> 2.75μs (4.26% faster)
    codeflash_output = reader.bool("baz", default_value=False) # 1.11μs -> 1.16μs (4.98% slower)

def test_bool_env_key_argument_as_list():
    # Basic: env_key as list, first found is used
    env = FakeEnv({"FIRST": False, "SECOND": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("unused", env_key=["first", "second"])  # "FIRST" is found first
    env2 = FakeEnv({"SECOND": True})
    reader2 = EnvironmentReader(env2)
    codeflash_output = reader2.bool("unused", env_key=["first", "second"])  # "SECOND" is found

def test_bool_with_enum_key():
    # Basic: key as Enum
    env = FakeEnv({"RED": True, "GREEN": False})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool(Color.RED) # 4.54μs -> 4.52μs (0.442% faster)
    codeflash_output = reader.bool(Color.GREEN) # 1.65μs -> 1.75μs (5.78% slower)

# --- Edge Test Cases ---

def test_bool_returns_none_when_key_missing_and_no_default():
    # Edge: key missing, no default_value
    env = FakeEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("missing")

def test_bool_with_empty_env_key_list():
    # Edge: env_key as empty list
    env = FakeEnv({"FOO": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key=[], default_value=False) # 4.00μs -> 4.03μs (0.621% slower)

def test_bool_with_empty_string_key():
    # Edge: key is empty string
    env = FakeEnv({"": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("") # 2.69μs -> 2.64μs (2.12% faster)



def test_bool_with_case_insensitive_keys():
    # Edge: keys are case-insensitive
    env = FakeEnv({"FOO": True, "foo": False})
    reader = EnvironmentReader(env)
    # Should match "FOO" regardless of input case
    codeflash_output = reader.bool("FoO") # 3.80μs -> 3.66μs (3.85% faster)

def test_bool_with_non_string_env_key():
    # Edge: env_key as list of mixed case
    env = FakeEnv({"A": True, "B": False})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("unused", env_key=["a", "b"]) # 2.90μs -> 2.95μs (1.93% slower)


def test_bool_with_none_default_value():
    # Edge: default_value is None, key missing
    env = FakeEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("notfound", default_value=None)

def test_bool_with_env_key_list_none_and_default():
    # Edge: env_key is None, default_value provided
    env = FakeEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("notfound", env_key=None, default_value=True) # 3.88μs -> 3.87μs (0.440% faster)

# --- Large Scale Test Cases ---

def test_bool_large_env_key_list_first_found():
    # Large: env_key list of 1000, only one key present
    keys = [f"KEY{i}" for i in range(1000)]
    env = FakeEnv({k: False for k in keys})
    env.mapping["KEY999"] = True  # Only the last key is True
    reader = EnvironmentReader(env)
    env_key_list = [f"key{i}" for i in range(1000)]  # lower case, should match
    codeflash_output = reader.bool("unused", env_key=env_key_list) # 3.29μs -> 3.24μs (1.58% faster)

def test_bool_large_env_key_list_last_found():
    # Large: env_key list, only last key present and True
    env = FakeEnv({f"KEY{i}": False for i in range(999)})
    env.mapping["KEY999"] = True
    reader = EnvironmentReader(env)
    env_key_list = [f"key{i}" for i in range(1000)]
    codeflash_output = reader.bool("unused", env_key=env_key_list) # 3.11μs -> 3.02μs (2.94% faster)
    # Remove first 999, only last remains
    env = FakeEnv({"KEY999": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("unused", env_key=env_key_list, default_value=False) # 149μs -> 108μs (37.3% faster)


def test_bool_performance_large_env():
    # Large: env with 1000 keys, ensure no performance issues
    mapping = {f"KEY{i}": (i % 2 == 0) for i in range(1000)}
    env = FakeEnv(mapping)
    reader = EnvironmentReader(env)
    # Pick a random key
    codeflash_output = reader.bool("key500") # 3.77μs -> 3.71μs (1.56% faster)
    codeflash_output = reader.bool("key501") # 1.24μs -> 1.13μs (9.73% faster)

def test_bool_large_env_key_list_all_missing():
    # Large: env_key list of 1000, none present, default returned
    env = FakeEnv({})
    reader = EnvironmentReader(env)
    env_key_list = [f"key{i}" for i in range(1000)]
    codeflash_output = reader.bool("foo", env_key=env_key_list, default_value=False) # 148μs -> 109μs (36.0% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.
#------------------------------------------------
from collections.abc import Callable
from enum import Enum
from typing import TypeVar

# imports
import pytest  # used for our unit tests
from environs import Env
from graphrag.config.environment_reader import EnvironmentReader

# ------------------------
# Unit Tests for bool()
# ------------------------

class DummyEnv:
    """
    Dummy environment class to simulate the 'environs.Env' interface,
    specifically the 'bool' method.
    """
    def __init__(self, values=None):
        self.values = values or {}

    def bool(self, key, default):
        # Simulate the environs.Env.bool method
        # Returns value if key present, else returns default
        if key in self.values:
            return self.values[key]
        return default

class DummyEnum(Enum):
    FOO = "FOO"
    BAR = "BAR"

# 1. Basic Test Cases

def test_bool_reads_from_section_when_present():
    # Should return value from section if present, regardless of env
    env = DummyEnv({"FOO": True})
    reader = EnvironmentReader(env)
    reader._config_stack.append({"foo": 0})  # section uses lower-case keys
    codeflash_output = reader.bool("foo") # 1.77μs -> 1.55μs (13.7% faster)

def test_bool_reads_from_env_when_section_missing():
    # Should fall back to env if section is missing
    env = DummyEnv({"FOO": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo") # 2.74μs -> 2.62μs (4.35% faster)

def test_bool_reads_from_env_when_section_key_missing():
    # Section present, but key not present, should fall back to env
    env = DummyEnv({"BAR": False})
    reader = EnvironmentReader(env)
    reader._config_stack.append({"foo": True})
    codeflash_output = reader.bool("bar") # 2.78μs -> 2.51μs (10.9% faster)

def test_bool_returns_default_if_not_in_section_or_env():
    # Should return default_value if not found in section or env
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", default_value=True) # 2.71μs -> 2.61μs (3.80% faster)

def test_bool_env_key_argument_takes_precedence():
    # Should use env_key if provided instead of key
    env = DummyEnv({"BAZ": True, "FOO": False})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key="baz") # 2.73μs -> 2.55μs (7.22% faster)

def test_bool_env_key_list_tries_all_keys():
    # Should try each env_key in order and return first found
    env = DummyEnv({"BAR": False, "BAZ": True})
    reader = EnvironmentReader(env)
    # BAR is present (False), so should return False, not check BAZ
    codeflash_output = reader.bool("foo", env_key=["bar", "baz"], default_value=True) # 2.62μs -> 2.66μs (1.43% slower)

def test_bool_env_key_list_returns_default_if_none_found():
    # Should return default if none of the env_keys are found
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key=["bar", "baz"], default_value=False) # 2.85μs -> 2.67μs (6.75% faster)

def test_bool_with_enum_key_reads_env():
    # Should handle Enum keys by using their value (lowercased)
    env = DummyEnv({"BAR": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool(DummyEnum.BAR) # 3.18μs -> 3.14μs (1.18% faster)

def test_bool_with_enum_key_reads_section():
    # Should handle Enum keys for section lookup
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    reader._config_stack.append({"bar": 1})
    codeflash_output = reader.bool(DummyEnum.BAR) # 2.23μs -> 2.04μs (9.61% faster)

# 2. Edge Test Cases

def test_bool_key_case_insensitivity():
    # Should treat keys case-insensitively in env and section
    env = DummyEnv({"FOO": False, "foo": True})  # Both present
    reader = EnvironmentReader(env)
    reader._config_stack.append({"Foo": 1, "bar": 0})
    # Section keys are lowercased by read_key, so "foo" matches "Foo"
    codeflash_output = reader.bool("FOO") # 2.79μs -> 2.50μs (11.9% faster)

def test_bool_env_key_with_mixed_case():
    # Should uppercase env_key before querying env
    env = DummyEnv({"FOOBAR": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key="fooBar") # 2.79μs -> 2.77μs (0.614% faster)

def test_bool_section_value_coercion():
    # Should coerce section value to bool (test with various types)
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    reader._config_stack.append({"foo": "yes", "bar": "", "baz": [], "qux": [1]})
    codeflash_output = reader.bool("foo") # 1.57μs -> 1.52μs (3.41% faster)
    codeflash_output = reader.bool("bar") # 801ns -> 648ns (23.6% faster)
    codeflash_output = reader.bool("baz") # 549ns -> 450ns (22.0% faster)
    codeflash_output = reader.bool("qux") # 505ns -> 396ns (27.5% faster)

def test_bool_returns_none_when_default_is_none_and_not_found():
    # Should return None if default_value is None and not found
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("notfound") # 2.46μs -> 2.40μs (2.58% faster)

def test_bool_env_key_empty_list_returns_default():
    # Should return default if env_key is empty list
    env = DummyEnv({"FOO": True})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key=[], default_value=False) # 2.65μs -> 2.71μs (2.11% slower)

def test_bool_section_empty_dict_falls_back_to_env():
    # If section is empty dict, should fall back to env
    env = DummyEnv({"FOO": True})
    reader = EnvironmentReader(env)
    reader._config_stack.append({})
    codeflash_output = reader.bool("foo") # 2.45μs -> 2.35μs (4.16% faster)

def test_bool_env_key_list_with_duplicates():
    # Should handle duplicate keys in env_key list
    env = DummyEnv({"FOO": False})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key=["foo", "foo"], default_value=True) # 2.65μs -> 2.67μs (0.711% slower)

def test_bool_env_key_with_non_string_key():
    # Should handle env_key with non-string (should raise or ignore)
    env = DummyEnv({"FOO": True})
    reader = EnvironmentReader(env)
    # Passing a non-string env_key should raise an error
    with pytest.raises(AttributeError):
        reader.bool("foo", env_key=123)

def test_bool_with_none_key_raises():
    # Passing None as key should raise
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    with pytest.raises(AttributeError):
        reader.bool(None) # 2.02μs -> 2.06μs (1.99% slower)

# 3. Large Scale Test Cases

def test_bool_env_key_list_large():
    # Should efficiently handle large env_key lists
    # Only the last key matches
    env_keys = [f"key{i}" for i in range(999)]
    env = DummyEnv({k.upper(): False for k in env_keys})
    env.values["KEY999"] = True  # Only the last key is True
    reader = EnvironmentReader(env)
    keys = env_keys + ["key999"]
    codeflash_output = reader.bool("foo", env_key=keys, default_value=False) # 147μs -> 107μs (37.0% faster)

def test_bool_section_large_dict():
    # Should efficiently handle large section dicts
    env = DummyEnv({})
    big_section = {f"key{i}": False for i in range(999)}
    big_section["foo"] = True
    reader = EnvironmentReader(env)
    reader._config_stack.append(big_section)
    codeflash_output = reader.bool("foo") # 1.88μs -> 1.75μs (7.36% faster)

def test_bool_env_large_env_dict():
    # Should efficiently handle large env dicts
    env_values = {f"KEY{i}": False for i in range(999)}
    env_values["FOO"] = True
    env = DummyEnv(env_values)
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo") # 2.80μs -> 2.86μs (2.03% slower)

def test_bool_env_key_list_all_missing_large():
    # Large env_key list, none found, should return default
    env_keys = [f"key{i}" for i in range(1000)]
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.bool("foo", env_key=env_keys, default_value=False) # 120μs -> 82.4μs (46.8% faster)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-EnvironmentReader.bool-mgludgz8 and push.