⚡️ Speed up method EnvironmentReader.list by 8%

[codeflash-ai]

📄 8% (0.08x) speedup for EnvironmentReader.list in graphrag/config/environment_reader.py

⏱️ Runtime : 570 microseconds → 527 microseconds (best of 151 runs)

📝 Explanation and details

The optimized code achieves an 8% speedup through three key improvements:

1. Optimized read_key() function: Reordered the type check to test isinstance(value, str) first instead of not isinstance(value, str). Since strings are the most common input type (96 out of 100 calls in profiling), this eliminates unnecessary negation overhead and checks the fast path first.

2. Eliminated lambda creation in str() method: Replaced the lambda (lambda k, dv: self._env(k, dv)) with a direct method reference self._env. This avoids creating a new function object on every call, reducing allocation overhead.

3. Optimized list parsing in list() method: Instead of using two list comprehensions ([s.strip() for s in result.split(",")] followed by [s for s in result if s]), the optimization uses a single loop that strips and filters in one pass. This reduces memory allocations and eliminates the intermediate list creation.

4. Added section caching: Used getattr(self, 'section', None) to cache section lookups instead of repeatedly accessing self.section, reducing attribute access overhead.

The optimizations are particularly effective for:

• Small to medium lists (most test cases show 15-35% improvements)
• Cases with many empty elements (up to 31% faster for empty strings and comma-only strings)
• Frequent string-type keys (the most common case)

For very large lists (1000+ elements), the improvement is minimal (1-2% slower) because the dominant cost becomes the actual string processing rather than the Python overhead being optimized.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 102 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 graphrag.config.environment_reader import EnvironmentReader


class DummyEnv:
    """
    Dummy environment class to simulate environment variable access.
    Behaves like a callable: DummyEnv()(key, default) returns value or default.
    """
    def __init__(self, mapping=None):
        self.mapping = mapping or {}

    def __call__(self, key, default):
        # Simulate environment variable lookup (case-insensitive)
        return self.mapping.get(key.upper(), default)

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

# ------------------- UNIT TESTS -------------------

# 1. Basic Test Cases

def test_list_returns_split_and_stripped_values():
    # Basic comma-separated string
    env = DummyEnv({"FOO": "a, b, c"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 5.52μs -> 4.62μs (19.5% faster)

def test_list_single_value():
    # Single value should return a one-element list
    env = DummyEnv({"FOO": "bar"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 4.17μs -> 3.50μs (19.0% faster)

def test_list_empty_string_results_in_empty_list():
    # Empty string should return empty list
    env = DummyEnv({"FOO": ""})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 4.13μs -> 3.16μs (30.7% faster)

def test_list_default_value_used_when_key_missing():
    # If env var missing, default should be returned
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", default_value=["default", "values"]) # 3.44μs -> 3.00μs (14.9% faster)

def test_list_with_enum_key():
    # Should handle Enum key (case-insensitive)
    env = DummyEnv({"BAR": "x, y"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list(DummyEnum.BAR) # 5.11μs -> 4.44μs (15.0% faster)

def test_list_with_custom_env_key():
    # Should use env_key argument if provided
    env = DummyEnv({"CUSTOM": "1,2,3"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", env_key="CUSTOM") # 4.54μs -> 3.81μs (19.3% faster)

def test_list_with_env_key_list():
    # Should search env_key list in order
    env = DummyEnv({"SECOND": "a,b"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", env_key=["FIRST", "SECOND"]) # 4.89μs -> 3.89μs (25.8% faster)



def test_list_with_extra_commas_and_spaces():
    # Should ignore extra commas and whitespace
    env = DummyEnv({"FOO": "  a , , b , , ,c, "})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 6.59μs -> 5.40μs (22.1% faster)

def test_list_with_only_commas():
    # Only commas should result in empty list
    env = DummyEnv({"FOO": ",,,"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 4.67μs -> 3.66μs (27.7% faster)


def test_list_with_none_env_value_and_no_default():
    # Key missing, no default: should return None
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 4.47μs -> 3.84μs (16.5% faster)

def test_list_with_none_env_value_and_empty_default():
    # Key missing, empty list default
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", default_value=[]) # 3.54μs -> 3.06μs (15.9% faster)

def test_list_with_env_key_case_insensitivity():
    # Env key lookup should be case-insensitive
    env = DummyEnv({"foo": "a,B"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO") # 3.14μs -> 2.79μs (12.4% faster)


def test_list_with_empty_env_key_list():
    # Empty env_key list should fallback to key
    env = DummyEnv({"FOO": "a,b"})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", env_key=[]) # 6.07μs -> 4.91μs (23.5% faster)

def test_list_with_env_key_list_no_match():
    # No env_key matches, should return default or None
    env = DummyEnv({})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("FOO", env_key=["X", "Y"], default_value=["d"]) # 3.87μs -> 3.32μs (16.5% faster)


def test_list_large_number_of_elements():
    # Large comma-separated string (1000 elements)
    values = [str(i) for i in range(1000)]
    env = DummyEnv({"BIG": ",".join(values)})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("BIG") # 56.3μs -> 58.9μs (4.34% slower)

def test_list_large_number_of_empty_elements():
    # 1000 commas, should result in empty list
    env = DummyEnv({"BIG": "," * 999})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("BIG") # 40.7μs -> 32.4μs (25.5% faster)



def test_list_performance_with_long_strings():
    # Large string with long elements
    values = ["x" * 100 for _ in range(1000)]
    env = DummyEnv({"BIG": ",".join(values)})
    reader = EnvironmentReader(env)
    codeflash_output = reader.list("BIG"); result = codeflash_output # 76.4μs -> 77.8μs (1.82% slower)
# 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 .list()
# --------------------------

class DummyEnv:
    """
    Dummy environment class to simulate os.environ-like access.
    Callable: DummyEnv(key, default) returns env[key] or default.
    """
    def __init__(self, mapping):
        self.mapping = {k.upper(): v for k, v in mapping.items()}

    def __call__(self, key, default=None):
        return self.mapping.get(key.upper(), default)

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

@pytest.fixture
def env_reader_factory():
    """Factory for EnvironmentReader with dummy env."""
    def _factory(env_dict):
        return EnvironmentReader(DummyEnv(env_dict))
    return _factory

# ------------------------
# BASIC TEST CASES
# ------------------------

def test_basic_single_value(env_reader_factory):
    # Single value, no commas
    er = env_reader_factory({"MY_KEY": "foo"})
    codeflash_output = er.list("MY_KEY") # 4.66μs -> 3.67μs (27.0% faster)

def test_basic_multiple_values(env_reader_factory):
    # Multiple comma-separated values
    er = env_reader_factory({"COLORS": "red,green,blue"})
    codeflash_output = er.list("COLORS") # 4.51μs -> 3.56μs (26.5% faster)

def test_basic_strip_whitespace(env_reader_factory):
    # Values with whitespace around commas
    er = env_reader_factory({"ITEMS": "  apple , banana ,carrot "})
    codeflash_output = er.list("ITEMS") # 4.62μs -> 3.77μs (22.4% faster)

def test_basic_empty_string(env_reader_factory):
    # Empty string returns empty list
    er = env_reader_factory({"EMPTY": ""})
    codeflash_output = er.list("EMPTY") # 4.21μs -> 3.20μs (31.4% faster)

def test_basic_default_value(env_reader_factory):
    # Key not present, default_value returned
    er = env_reader_factory({})
    codeflash_output = er.list("NOT_FOUND", default_value=["x", "y"]) # 3.57μs -> 3.10μs (15.0% faster)

def test_basic_env_key_list(env_reader_factory):
    # Try multiple env keys in order
    er = env_reader_factory({"A": "1", "B": "2"})
    codeflash_output = er.list("unused", env_key=["C", "B", "A"]) # 4.76μs -> 3.71μs (28.2% faster)

def test_basic_enum_key(env_reader_factory):
    # Enum key usage
    er = env_reader_factory({"RED": "fire,rose"})
    codeflash_output = er.list(Color.RED) # 4.98μs -> 4.37μs (13.8% faster)

def test_basic_env_key_priority(env_reader_factory):
    # env_key overrides key
    er = env_reader_factory({"MYENV": "a,b"})
    codeflash_output = er.list("MY_KEY", env_key="MYENV") # 4.45μs -> 3.71μs (19.9% faster)

# ------------------------
# EDGE TEST CASES
# ------------------------

def test_edge_all_empty_items(env_reader_factory):
    # String of just commas and spaces
    er = env_reader_factory({"FOO": " , , , "})
    codeflash_output = er.list("FOO") # 4.29μs -> 3.48μs (23.2% faster)

def test_edge_some_empty_items(env_reader_factory):
    # Some empty items between commas
    er = env_reader_factory({"FOO": "a,,b, ,c"})
    codeflash_output = er.list("FOO") # 4.68μs -> 3.79μs (23.6% faster)

def test_edge_only_spaces(env_reader_factory):
    # Value is only spaces
    er = env_reader_factory({"FOO": "    "})
    codeflash_output = er.list("FOO") # 3.97μs -> 3.14μs (26.4% faster)

def test_edge_none_in_env_returns_default(env_reader_factory):
    # None in env, should return default
    er = env_reader_factory({"FOO": None})
    codeflash_output = er.list("FOO", default_value=["x"]) # 3.35μs -> 2.83μs (18.1% faster)

def test_edge_section_list_value_overrides_env(env_reader_factory):
    # Section (config stack) with list value overrides env
    er = env_reader_factory({"FOO": "env1,env2"})
    er._config_stack.append({"foo": ["section1", "section2"]})
    codeflash_output = er.list("FOO") # 1.55μs -> 1.44μs (7.94% faster)

def test_edge_section_str_value(env_reader_factory):
    # Section (config stack) with string value, not list
    er = env_reader_factory({"FOO": "env1,env2"})
    er._config_stack.append({"foo": "section1, section2"})
    codeflash_output = er.list("FOO") # 2.84μs -> 2.98μs (4.47% slower)

def test_edge_section_empty_list(env_reader_factory):
    # Section with empty list
    er = env_reader_factory({"FOO": "env1"})
    er._config_stack.append({"foo": []})
    codeflash_output = er.list("FOO") # 1.45μs -> 1.38μs (5.24% faster)

def test_edge_env_key_case_insensitive(env_reader_factory):
    # Env keys are case-insensitive
    er = env_reader_factory({"MyKey": "a,b"})
    codeflash_output = er.list("mykey") # 4.47μs -> 3.74μs (19.5% faster)
    codeflash_output = er.list("MYKEY") # 2.12μs -> 1.57μs (34.9% faster)

def test_edge_env_key_list_priority(env_reader_factory):
    # env_key list, second key is found
    er = env_reader_factory({"A": "x", "B": "y"})
    codeflash_output = er.list("foo", env_key=["Z", "B", "A"]) # 4.44μs -> 3.77μs (17.8% faster)

def test_edge_env_key_not_found_returns_default(env_reader_factory):
    # env_key not found, returns default_value
    er = env_reader_factory({})
    codeflash_output = er.list("foo", env_key=["X", "Y"], default_value=["d"]) # 3.61μs -> 3.10μs (16.3% faster)

def test_edge_env_value_is_none_returns_default(env_reader_factory):
    # Env value is None, should return default
    er = env_reader_factory({"FOO": None})
    codeflash_output = er.list("FOO", default_value=["a"]) # 3.46μs -> 3.10μs (11.5% faster)

def test_edge_env_value_is_integer(env_reader_factory):
    # Env value is integer, should raise AttributeError (no split)
    er = env_reader_factory({"FOO": 123})
    with pytest.raises(AttributeError):
        er.list("FOO") # 4.58μs -> 3.91μs (17.1% faster)

def test_edge_section_value_is_integer(env_reader_factory):
    # Section value is integer, should raise AttributeError (no split)
    er = env_reader_factory({"FOO": "a"})
    er._config_stack.append({"foo": 42})
    with pytest.raises(AttributeError):
        er.list("FOO") # 2.68μs -> 2.95μs (9.10% slower)

def test_edge_env_value_is_list(env_reader_factory):
    # Env value is a list, should convert to string and split (should fail)
    er = env_reader_factory({"FOO": ["a", "b"]})
    # This will call str(["a", "b"]) -> "['a', 'b']"
    codeflash_output = er.list("FOO")

# ------------------------
# LARGE SCALE TEST CASES
# ------------------------

def test_large_scale_many_items(env_reader_factory):
    # 1000 comma-separated items
    items = [f"item{i}" for i in range(1000)]
    er = env_reader_factory({"BIG": ",".join(items)})
    codeflash_output = er.list("BIG") # 55.3μs -> 56.4μs (2.02% slower)

def test_large_scale_section_overrides_env(env_reader_factory):
    # Section with 1000 items overrides env
    items = [str(i) for i in range(1000)]
    er = env_reader_factory({"FOO": "x,y"})
    er._config_stack.append({"foo": items})
    codeflash_output = er.list("FOO") # 1.73μs -> 1.62μs (6.72% faster)

def test_large_scale_empty_items(env_reader_factory):
    # 1000 commas, should return empty list
    er = env_reader_factory({"FOO": "," * 999})
    codeflash_output = er.list("FOO") # 41.2μs -> 33.0μs (24.9% faster)

def test_large_scale_sparse_items(env_reader_factory):
    # 1000 items, every other is empty
    s = ",".join("" if i % 2 == 0 else f"v{i}" for i in range(1000))
    er = env_reader_factory({"FOO": s})
    expected = [f"v{i}" for i in range(1000) if i % 2 == 1]
    codeflash_output = er.list("FOO") # 49.6μs -> 45.9μs (8.08% faster)

def test_large_scale_long_strings(env_reader_factory):
    # 1000 items, each a long string
    long_item = "x" * 100
    items = [long_item for _ in range(1000)]
    er = env_reader_factory({"FOO": ",".join(items)})
    codeflash_output = er.list("FOO") # 75.8μs -> 77.1μs (1.73% slower)

# ------------------------
# DETERMINISM TEST
# ------------------------

def test_determinism_same_input_same_output(env_reader_factory):
    # Multiple calls with same input yield same output
    er = env_reader_factory({"FOO": "a,b,c"})
    codeflash_output = er.list("FOO"); out1 = codeflash_output # 4.71μs -> 3.81μs (23.5% faster)
    codeflash_output = er.list("FOO"); out2 = codeflash_output # 2.12μs -> 1.60μs (32.6% faster)

# ------------------------
# FUNCTIONAL MUTATION TESTS
# ------------------------

def test_mutation_wrong_split_character(env_reader_factory):
    # If comma replaced with semicolon in split, test fails
    er = env_reader_factory({"FOO": "a,b;c"})
    # Should split only on comma, so "b;c" is one item
    codeflash_output = er.list("FOO") # 3.96μs -> 3.25μs (21.7% faster)

def test_mutation_wrong_strip(env_reader_factory):
    # If strip is not used, test fails
    er = env_reader_factory({"FOO": " a ,b "})
    codeflash_output = er.list("FOO") # 4.30μs -> 3.46μs (24.4% faster)

def test_mutation_wrong_empty_removal(env_reader_factory):
    # If empty items are not removed, test fails
    er = env_reader_factory({"FOO": "a,,b"})
    codeflash_output = er.list("FOO") # 4.19μs -> 3.48μs (20.4% faster)

def test_mutation_wrong_section_priority(env_reader_factory):
    # Section must override env
    er = env_reader_factory({"FOO": "env"})
    er._config_stack.append({"foo": ["section"]})
    codeflash_output = er.list("FOO") # 1.57μs -> 1.37μs (14.9% faster)

def test_mutation_wrong_env_key_priority(env_reader_factory):
    # env_key list: first found key is used
    er = env_reader_factory({"A": "x", "B": "y"})
    codeflash_output = er.list("foo", env_key=["B", "A"]) # 4.41μs -> 3.60μs (22.4% 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.list-mglun0at and push.