fix: build full dotted name in _expr_name for module-qualified decorators/bases

_expr_name now recurses into ast.Attribute to produce the full dotted
path (e.g. "dataclasses.dataclass", "typing.NamedTuple"). Callers use
.endswith() so both bare and module-qualified forms are matched. Adds
test for typing.NamedTuple base class.

Author: KRRT7

codeflash/verification/instrument_codeflash_capture.py

@@ -179,13 +179,13 @@ def visit_ClassDef(self, node: ast.ClassDef) -> ast.ClassDef:
             # _orig_init = ClassName.__init__; then calling _orig_init(self, *args, **kwargs) in the wrapper
             for dec in node.decorator_list:
                 dec_name = self._expr_name(dec)
-                if dec_name == "dataclass":
+                if dec_name is not None and dec_name.endswith("dataclass"):
                     return node
 
             # Skip NamedTuples — their __init__ is synthesized and cannot be overwritten.
             for base in node.bases:
                 base_name = self._expr_name(base)
-                if base_name == "NamedTuple":
+                if base_name is not None and base_name.endswith("NamedTuple"):
                     return node
 
             # Create super().__init__(*args, **kwargs) call (use prebuilt AST fragments)
@@ -208,5 +208,6 @@ def _expr_name(self, node: ast.AST) -> str | None:
         if isinstance(node, ast.Call):
             return self._expr_name(node.func)
         if isinstance(node, ast.Attribute):
-            return node.attr
+            parent = self._expr_name(node.value)
+            return f"{parent}.{node.attr}" if parent else node.attr
         return None

tests/test_instrument_codeflash_capture.py

@@ -471,6 +471,34 @@ def magnitude(self):
         test_path.unlink(missing_ok=True)
 
 
+def test_module_qualified_namedtuple_skipped():
+    """typing.NamedTuple — module-qualified base class — should be skipped."""
+    original_code = """
+import typing
+
+class MyTuple(typing.NamedTuple):
+    x: int
+    y: str
+
+    def display(self):
+        return f"{self.x}: {self.y}"
+"""
+    test_path = (Path(__file__).parent.resolve() / "../code_to_optimize/tests/pytest/test_file.py").resolve()
+    test_path.write_text(original_code)
+
+    function = FunctionToOptimize(
+        function_name="display", file_path=test_path, parents=[FunctionParent(type="ClassDef", name="MyTuple")]
+    )
+
+    try:
+        instrument_codeflash_capture(function, {}, test_path.parent)
+        modified_code = test_path.read_text()
+        assert "super().__init__" not in modified_code
+        assert "codeflash_capture" not in modified_code
+    finally:
+        test_path.unlink(missing_ok=True)
+
+
 def test_dataclass_with_explicit_init_still_instrumented():
     """A dataclass that defines its own __init__ should still be instrumented normally."""
     original_code = """