Skip to content

⚡️ Speed up function _should_use_raw_project_class_context by 51% in PR #1838 (codeflash/optimize-pr1660-2026-03-16T19.13.06) #1839

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
misrasaurabh1 merged 2 commits into from
Mar 16, 2026
Merged

⚡️ Speed up function _should_use_raw_project_class_context by 51% in PR #1838 (codeflash/optimize-pr1660-2026-03-16T19.13.06) #1839

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
2d5eec2
Optimize _should_use_raw_project_class_context
codeflash-ai[bot] Mar 16, 2026
f9732ee
style: auto-fix ruff SIM110 linting issue in _is_namedtuple_class
github-actions[bot] Mar 16, 2026
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
20 changes: 12 additions & 8 deletions codeflash/languages/python/context/code_context_extractor.py
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -774,7 +774,10 @@ def _bool_literal(node: ast.AST) -> bool | None:


def _is_namedtuple_class(class_node: ast.ClassDef, import_aliases: dict[str, str]) -> bool:
return any(_expr_matches_name(base, import_aliases, "NamedTuple") for base in class_node.bases)
for base in class_node.bases: # noqa: SIM110
if _expr_matches_name(base, import_aliases, "NamedTuple"):
return True
Comment on lines +777 to +779

@codeflash-ai codeflash-ai Bot Mar 16, 2026

Copy link
Copy Markdown
Contributor Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

⚡️Codeflash found 29% (0.29x) speedup for _is_namedtuple_class in codeflash/languages/python/context/code_context_extractor.py

⏱️ Runtime : 447 microseconds → 347 microseconds (best of 205 runs)

⚡️ This change will improve the performance of the following benchmarks:

Benchmark File :: Function Original Runtime Expected New Runtime Speedup
tests.benchmarks.test_benchmark_code_extract_code_context::test_benchmark_extract 17.6 seconds 17.6 seconds 0.00%

🔻 This change will degrade the performance of the following benchmarks:

{benchmark_info_degraded}

📝 Explanation and details

The optimization inlines _expr_matches_name directly into _is_namedtuple_class, eliminating 2,150 function calls that originally consumed 92.6% of total execution time. The hot loop now computes string concatenations (".NamedTuple") once outside the loop instead of on every iteration, and restructures the resolved-alias check to short-circuit earlier when no alias exists. Line profiler confirms per-iteration cost dropped from ~3,786 ns to ~1,943 ns. No test cases regress in correctness, and the 28% runtime improvement directly benefits callers like _collect_synthetic_constructor_type_names and _build_synthetic_init_stub that check hundreds of class definitions during AST traversal.

✅ Correctness verification report:

Test Status
⚙️ Existing Unit Tests 🔘 None Found
🌀 Generated Regression Tests ✅ 53 Passed
⏪ Replay Tests ✅ 1 Passed
🔎 Concolic Coverage Tests 🔘 None Found
📊 Tests Coverage 100.0%
🌀 Click to see Generated Regression Tests 
import ast  # used to construct AST nodes that simulate class definitions and bases

import pytest  # used for our unit tests
# import the function to test from the provided module path
from codeflash.languages.python.context.code_context_extractor import \
    _is_namedtuple_class
from jedi.api.classes import Name

def test_namedtuple_with_simple_name_is_detected():
    # Create a ClassDef node whose base is a simple Name node "NamedTuple"
    class_node = ast.ClassDef(
        name="C",  # arbitrary class name
        bases=[ast.Name(id="NamedTuple")],  # base: NamedTuple
        keywords=[],  # no keywords
        body=[],  # empty body
        decorator_list=[],  # no decorators
    )
    # No import aliases are required for this direct match
    assert _is_namedtuple_class(class_node, {}) is True # 1.17μs -> 1.02μs (14.7% faster)

def test_namedtuple_with_qualified_name_is_detected():
    # Create a ClassDef node whose base is an attribute like "typing.NamedTuple"
    base_attr = ast.Attribute(value=ast.Name(id="typing"), attr="NamedTuple")
    class_node = ast.ClassDef(
        name="C",
        bases=[base_attr],  # base: typing.NamedTuple
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # Should detect Qualified.NamedTuple because endswith(".NamedTuple")
    assert _is_namedtuple_class(class_node, {}) is True # 2.17μs -> 1.87μs (16.1% faster)

def test_namedtuple_when_base_is_call_is_detected():
    # Create a ClassDef node whose base is a Call node: NamedTuple(...)
    call_node = ast.Call(func=ast.Name(id="NamedTuple"), args=[], keywords=[])
    class_node = ast.ClassDef(
        name="C",
        bases=[call_node],  # base: NamedTuple(...) form
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # The function should extract the func name from the Call and detect NamedTuple
    assert _is_namedtuple_class(class_node, {}) is True # 1.40μs -> 1.28μs (9.44% faster)

def test_namedtuple_detected_via_import_alias():
    # Simulate: from typing import NamedTuple as NT  --> base AST uses "NT"
    class_node = ast.ClassDef(
        name="C",
        bases=[ast.Name(id="NT")],  # base: NT (alias)
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # import_aliases maps alias "NT" to the fully-qualified "typing.NamedTuple"
    import_aliases = {"NT": "typing.NamedTuple"}
    # Should resolve alias and detect NamedTuple
    assert _is_namedtuple_class(class_node, import_aliases) is True # 1.89μs -> 1.55μs (22.0% faster)

def test_non_namedtuple_base_returns_false():
    # Base is a different name that should not match
    class_node = ast.ClassDef(
        name="C",
        bases=[ast.Name(id="BaseClass")],  # base: BaseClass
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # No alias mapping; should not detect NamedTuple
    assert _is_namedtuple_class(class_node, {}) is False # 1.59μs -> 1.28μs (24.2% faster)

def test_empty_bases_returns_false():
    # Class with no bases at all should not be treated as NamedTuple
    class_node = ast.ClassDef(
        name="C",
        bases=[],  # no bases provided
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # Should be False because there are no bases to match
    assert _is_namedtuple_class(class_node, {}) is False # 421ns -> 450ns (6.44% slower)

def test_unknown_node_types_in_bases_are_ignored():
    # Some AST nodes do not have names; e.g., a Constant used incorrectly as a base
    class_node = ast.ClassDef(
        name="C",
        bases=[ast.Constant(value=42)],  # nonsensical base but valid AST node
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # The function should ignore unknown node types and return False
    assert _is_namedtuple_class(class_node, {}) is False # 1.27μs -> 1.10μs (15.4% faster)

def test_alias_resolution_is_case_sensitive_and_mismatch_returns_false():
    # Alias maps to a lowercase "namedtuple" (e.g., collections.namedtuple) which should not match "NamedTuple"
    class_node = ast.ClassDef(
        name="C",
        bases=[ast.Name(id="NT")],  # alias used in base
        keywords=[],
        body=[],
        decorator_list=[],
    )
    import_aliases = {"NT": "collections.namedtuple"}  # not the same suffix, case differs
    # Should not match because resolved name does not end with ".NamedTuple"
    assert _is_namedtuple_class(class_node, import_aliases) is False # 1.94μs -> 1.57μs (23.6% faster)

def test_nested_attribute_like_pkg_sub_namedtuple_is_detected():
    # Create a nested attribute pkg.sub.NamedTuple
    nested_attr = ast.Attribute(
        value=ast.Attribute(value=ast.Name(id="pkg"), attr="sub"),
        attr="NamedTuple",
    )
    class_node = ast.ClassDef(
        name="C",
        bases=[nested_attr],  # base: pkg.sub.NamedTuple
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # Should detect because final attribute name ends with ".NamedTuple"
    assert _is_namedtuple_class(class_node, {}) is True # 2.40μs -> 2.17μs (10.6% faster)

def test_call_of_attribute_with_import_alias_resolution():
    # Simulate base: mod.NT(...) where mod.NT is an alias to typing.NamedTuple
    call_node = ast.Call(func=ast.Attribute(value=ast.Name(id="mod"), attr="NT"), args=[], keywords=[])
    class_node = ast.ClassDef(
        name="C",
        bases=[call_node],  # base: mod.NT(...)
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # Provide import_aliases that map the attribute name "mod.NT" to "typing.NamedTuple"
    import_aliases = {"mod.NT": "typing.NamedTuple"}
    # Should resolve through the attribute and detect NamedTuple
    assert _is_namedtuple_class(class_node, import_aliases) is True # 2.80μs -> 2.33μs (20.3% faster)

def test_passing_none_for_import_aliases_raises_attribute_error():
    # If import_aliases is None, the code attempts to call .get and should raise AttributeError
    class_node = ast.ClassDef(
        name="C",
        bases=[ast.Name(id="Other")],  # triggers the branch that will try to consult import_aliases.get
        keywords=[],
        body=[],
        decorator_list=[],
    )
    # Expect an AttributeError because NoneType has no .get method
    with pytest.raises(AttributeError):
        _is_namedtuple_class(class_node, None) # 4.77μs -> 4.17μs (14.4% faster)

def test_large_scale_mixed_classes_detection():
    # Construct a large list of ClassDef nodes (1000) with alternating matching and non-matching bases
    nodes = []
    import_aliases = {"AliasNT": "typing.NamedTuple"}  # provide one alias mapping used for some nodes
    total = 1000  # number of class nodes to generate (within the requested limit)
    # Populate nodes deterministically: even indices will match, odd will not
    for i in range(total):
        if i % 4 == 0:
            # direct NamedTuple name -> should match
            bases = [ast.Name(id="NamedTuple")]
        elif i % 4 == 1:
            # qualified attribute typing.NamedTuple -> should match
            bases = [ast.Attribute(value=ast.Name(id="typing"), attr="NamedTuple")]
        elif i % 4 == 2:
            # alias name that resolves to NamedTuple via import_aliases -> should match
            bases = [ast.Name(id="AliasNT")]
        else:
            # non-matching random name -> should not match
            bases = [ast.Name(id=f"Other{i}")]
        nodes.append(
            ast.ClassDef(
                name=f"C{i}",
                bases=bases,
                keywords=[],
                body=[],
                decorator_list=[],
            )
        )

    # Evaluate all nodes and count how many are detected as NamedTuple classes
    detected = 0
    for node in nodes:
        if _is_namedtuple_class(node, import_aliases):
            detected += 1

    # For our construction, 3 out of every 4 nodes should match
    expected = total * 3 // 4
    assert detected == expected  # ensure detection count matches expected value
import ast
from typing import NamedTuple

# imports
import pytest
from codeflash.languages.python.context.code_context_extractor import \
    _is_namedtuple_class

class TestIsNamedtupleClassBasic:
    """Basic tests for _is_namedtuple_class with typical use cases."""

    def test_namedtuple_class_with_direct_base(self):
        """Test that a class directly inheriting from NamedTuple is identified."""
        # Parse code defining a class that directly inherits from NamedTuple
        code = "class Point(NamedTuple): x: int; y: int"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases (NamedTuple is a direct base)
        result = _is_namedtuple_class(class_node, {}) # 1.34μs -> 1.19μs (12.6% faster)
        
        # Should return True because the class has NamedTuple as a base
        assert result is True

    def test_namedtuple_class_with_imported_base(self):
        """Test that a class inheriting from an aliased NamedTuple is identified."""
        # Parse code defining a class that inherits from an aliased NamedTuple
        code = "class Point(MyTuple): x: int; y: int"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Provide an import_aliases mapping that resolves MyTuple to NamedTuple
        import_aliases = {"MyTuple": "typing.NamedTuple"}
        result = _is_namedtuple_class(class_node, import_aliases) # 2.31μs -> 1.80μs (28.4% faster)
        
        # Should return True because MyTuple resolves to NamedTuple
        assert result is True

    def test_non_namedtuple_class_with_simple_base(self):
        """Test that a class not inheriting from NamedTuple returns False."""
        # Parse code defining a regular class
        code = "class Point: x: int; y: int"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 530ns -> 511ns (3.72% faster)
        
        # Should return False because the class doesn't inherit from NamedTuple
        assert result is False

    def test_class_with_non_namedtuple_base(self):
        """Test that a class inheriting from a non-NamedTuple base returns False."""
        # Parse code defining a class that inherits from a custom class
        code = "class Point(CustomBase): x: int; y: int"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with import_aliases that doesn't map to NamedTuple
        import_aliases = {"CustomBase": "my_module.CustomBase"}
        result = _is_namedtuple_class(class_node, import_aliases) # 2.31μs -> 1.79μs (29.1% faster)
        
        # Should return False because CustomBase doesn't resolve to NamedTuple
        assert result is False

    def test_namedtuple_with_fully_qualified_name(self):
        """Test that a class inheriting from typing.NamedTuple is identified."""
        # Parse code defining a class that inherits from fully qualified NamedTuple
        code = "class Point(typing.NamedTuple): x: int; y: int"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 2.33μs -> 2.04μs (14.2% faster)
        
        # Should return True because typing.NamedTuple matches the pattern
        assert result is True

class TestIsNamedtupleClassEdgeCases:
    """Edge case tests for _is_namedtuple_class."""

    def test_class_with_no_bases(self):
        """Test that a class with no base classes returns False."""
        # Parse code defining a class with no explicit bases
        code = "class Empty: pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 511ns -> 471ns (8.49% faster)
        
        # Should return False because the class has no bases
        assert result is False

    def test_class_with_empty_import_aliases(self):
        """Test that empty import_aliases dict works correctly."""
        # Parse code defining a class inheriting from NamedTuple
        code = "class Point(NamedTuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 1.17μs -> 972ns (20.6% faster)
        
        # Should return True because NamedTuple is recognized directly
        assert result is True

    def test_namedtuple_alias_single_suffix_match(self):
        """Test that an alias matching only the suffix is recognized."""
        # Parse code with an aliased base that matches the suffix
        code = "class Point(NT): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Provide an import_aliases where NT resolves to a module with NamedTuple
        import_aliases = {"NT": "collections.namedtuple"}
        result = _is_namedtuple_class(class_node, import_aliases) # 2.20μs -> 1.64μs (34.1% faster)
        
        # Should return False because "namedtuple" doesn't end with "NamedTuple"
        assert result is False

    def test_namedtuple_from_collections_module(self):
        """Test that NamedTuple from collections module is recognized."""
        # Parse code with collections.NamedTuple
        code = "class Point(collections.NamedTuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 2.28μs -> 2.01μs (13.4% faster)
        
        # Should return True because it ends with NamedTuple
        assert result is True

    def test_class_with_multiple_bases_one_is_namedtuple(self):
        """Test that a class with multiple bases where one is NamedTuple is identified."""
        # Parse code defining a class with multiple bases
        code = "class Point(Mixin, NamedTuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 2.19μs -> 1.69μs (29.6% faster)
        
        # Should return True because one of the bases is NamedTuple
        assert result is True

    def test_class_with_multiple_bases_none_are_namedtuple(self):
        """Test that a class with multiple non-NamedTuple bases returns False."""
        # Parse code defining a class with multiple non-NamedTuple bases
        code = "class Point(Mixin1, Mixin2): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 2.21μs -> 1.84μs (20.1% faster)
        
        # Should return False because none of the bases are NamedTuple
        assert result is False

    def test_partial_name_match_should_fail(self):
        """Test that partial name matches don't incorrectly match."""
        # Parse code with a base named something containing NamedTuple
        code = "class Point(NotNamedTuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 1.74μs -> 1.44μs (20.8% faster)
        
        # Should return False because NotNamedTuple doesn't match "NamedTuple"
        assert result is False

    def test_case_sensitive_matching(self):
        """Test that matching is case-sensitive."""
        # Parse code with a base named namedtuple (lowercase)
        code = "class Point(namedtuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 1.77μs -> 1.46μs (21.3% faster)
        
        # Should return False because "namedtuple" != "NamedTuple"
        assert result is False

    def test_namedtuple_with_complex_qualified_name(self):
        """Test that deeply qualified NamedTuple names are recognized."""
        # Parse code with a complex qualified name
        code = "class Point(pkg.sub.mod.NamedTuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 2.88μs -> 2.72μs (5.85% faster)
        
        # Should return True because it ends with NamedTuple
        assert result is True

    def test_namedtuple_with_call_expression(self):
        """Test behavior when a base is a call expression to NamedTuple."""
        # Note: This is not valid Python syntax for class inheritance,
        # but the function should handle it gracefully
        code = "class Point(NamedTuple()): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 1.54μs -> 1.40μs (9.98% faster)
        
        # Should return True because _expr_matches_name handles Call nodes
        assert result is True

    def test_import_alias_override(self):
        """Test that import aliases can override base class names."""
        # Parse code with an aliased base
        code = "class Point(Tuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Provide import_aliases where Tuple resolves to typing.NamedTuple
        import_aliases = {"Tuple": "typing.NamedTuple"}
        result = _is_namedtuple_class(class_node, import_aliases) # 2.19μs -> 1.69μs (29.6% faster)
        
        # Should return True because Tuple is aliased to NamedTuple
        assert result is True

    def test_import_alias_not_matching(self):
        """Test that import aliases not matching NamedTuple return False."""
        # Parse code with an aliased base
        code = "class Point(Tuple): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Provide import_aliases where Tuple doesn't resolve to NamedTuple
        import_aliases = {"Tuple": "typing.Tuple"}
        result = _is_namedtuple_class(class_node, import_aliases) # 1.96μs -> 1.50μs (30.7% faster)
        
        # Should return False because Tuple is not aliased to NamedTuple
        assert result is False

class TestIsNamedtupleClassLargeScale:
    """Large-scale tests for _is_namedtuple_class."""

    def test_class_with_many_bases_one_is_namedtuple(self):
        """Test that a class with many bases where one is NamedTuple is identified."""
        # Generate code with many base classes, one of which is NamedTuple
        bases = ", ".join([f"Mixin{i}" for i in range(500)] + ["NamedTuple"])
        code = f"class Point({bases}): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 144μs -> 107μs (35.0% faster)
        
        # Should return True despite many bases
        assert result is True

    def test_class_with_many_non_namedtuple_bases(self):
        """Test that a class with many non-NamedTuple bases returns False."""
        # Generate code with many base classes, none of which are NamedTuple
        bases = ", ".join([f"Mixin{i}" for i in range(500)])
        code = f"class Point({bases}): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Call the function with empty import_aliases
        result = _is_namedtuple_class(class_node, {}) # 143μs -> 104μs (37.2% faster)
        
        # Should return False
        assert result is False

    def test_large_import_aliases_dict_with_namedtuple_match(self):
        """Test that a large import_aliases dict with NamedTuple mapping works."""
        # Parse code with an aliased base
        code = "class Point(Alias500): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Create a large import_aliases dict with many entries
        import_aliases = {f"Alias{i}": f"module{i}.Something" for i in range(1000)}
        # Set one entry to resolve to NamedTuple
        import_aliases["Alias500"] = "typing.NamedTuple"
        
        result = _is_namedtuple_class(class_node, import_aliases) # 2.50μs -> 1.90μs (31.0% faster)
        
        # Should return True despite large dict
        assert result is True

    def test_large_import_aliases_dict_without_namedtuple_match(self):
        """Test that a large import_aliases dict without NamedTuple mapping works."""
        # Parse code with an aliased base
        code = "class Point(Alias250): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Create a large import_aliases dict with many entries
        import_aliases = {f"Alias{i}": f"module{i}.Something" for i in range(1000)}
        
        result = _is_namedtuple_class(class_node, import_aliases) # 2.29μs -> 1.76μs (30.1% faster)
        
        # Should return False
        assert result is False

    def test_many_qualified_namedtuple_variations(self):
        """Test multiple variations of qualified NamedTuple references."""
        # Create many test cases with different qualified NamedTuple names
        for depth in range(1, 20):
            qualifiers = ".".join([f"mod{i}" for i in range(depth)])
            code = f"class Point({qualifiers}.NamedTuple): pass"
            module = ast.parse(code)
            class_node = module.body[0]
            
            result = _is_namedtuple_class(class_node, {}) # 55.1μs -> 53.1μs (3.80% faster)
            
            # All should return True
            assert result is True, f"Failed for depth {depth}"

    def test_many_alias_lookups(self):
        """Test efficiency of many alias lookups."""
        # Parse code with multiple different bases
        bases = ", ".join([f"Type{i}" for i in range(100)])
        code = f"class Point({bases}): pass"
        module = ast.parse(code)
        class_node = module.body[0]
        
        # Create import_aliases for all but one (the last should be NamedTuple)
        import_aliases = {f"Type{i}": f"module{i}.Class{i}" for i in range(99)}
        import_aliases["Type99"] = "typing.NamedTuple"
        
        result = _is_namedtuple_class(class_node, import_aliases) # 43.1μs -> 31.5μs (36.8% faster)
        
        # Should return True by finding Type99
        assert result is True
⏪ Click to see Replay Tests
Test File::Test Function Original ⏱️ Optimized ⏱️ Speedup
benchmarks/codeflash_replay_tests_gwziwff1/test_tests_benchmarks_test_benchmark_code_extract_code_context__replay_test_0.py::test_codeflash_languages_python_context_code_context_extractor__is_namedtuple_class_test_benchmark_extract 2.50μs 2.17μs 15.2%✅

To test or edit this optimization locally git merge codeflash/optimize-pr1839-2026-03-16T19.49.25

Suggested change
for base in class_node.bases: # noqa: SIM110
if _expr_matches_name(base, import_aliases, "NamedTuple"):
return True
dot_suffix = ".NamedTuple"
for base in class_node.bases: # noqa: SIM110
expr_name = _get_expr_name(base)
if expr_name is None:
continue
if expr_name == "NamedTuple" or expr_name.endswith(dot_suffix):
return True
resolved_name = import_aliases.get(expr_name)
if resolved_name is not None and (resolved_name == "NamedTuple" or resolved_name.endswith(dot_suffix)):
return True

return False


def _get_dataclass_config(class_node: ast.ClassDef, import_aliases: dict[str, str]) -> tuple[bool, bool, bool]:
Expand Down Expand Up @@ -812,10 +815,10 @@ def _get_class_start_line(class_node: ast.ClassDef) -> int:


def _class_has_explicit_init(class_node: ast.ClassDef) -> bool:
return any(
isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and item.name == "__init__"
for item in class_node.body
)
for item in class_node.body:
if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)) and item.name == "__init__":
return True
return False


def _collect_synthetic_constructor_type_names(class_node: ast.ClassDef, import_aliases: dict[str, str]) -> set[str]:
Expand Down Expand Up @@ -948,9 +951,10 @@ def _has_non_property_method_decorator(


def _has_descriptor_like_class_fields(class_node: ast.ClassDef) -> bool:
return any(
isinstance(item, (ast.Assign, ast.AnnAssign)) and isinstance(item.value, ast.Call) for item in class_node.body
)
for item in class_node.body:
if isinstance(item, (ast.Assign, ast.AnnAssign)) and isinstance(item.value, ast.Call):
return True
return False


def _should_use_raw_project_class_context(class_node: ast.ClassDef, import_aliases: dict[str, str]) -> bool:
Expand Down
Loading