Limitations

Author: codeSamuraii

pyfuse/core/models.py

@@ -44,6 +44,9 @@ class FunctionNode:
     closure_func_refs: dict[str, str] = field(default_factory=dict)
     module_vars: dict[str, str] = field(default_factory=dict)
     class_bases: list[str] = field(default_factory=list)
+    class_keywords: dict[str, str] = field(default_factory=dict)
+    class_attrs: list[str] = field(default_factory=list)
+    class_decorators: list[str] = field(default_factory=list)
 
     def to_dict(self) -> dict[str, Any]:
         d: dict[str, Any] = {
@@ -63,6 +66,12 @@ def to_dict(self) -> dict[str, Any]:
             d["module_vars"] = dict(self.module_vars)
         if self.class_bases:
             d["class_bases"] = list(self.class_bases)
+        if self.class_keywords:
+            d["class_keywords"] = dict(self.class_keywords)
+        if self.class_attrs:
+            d["class_attrs"] = list(self.class_attrs)
+        if self.class_decorators:
+            d["class_decorators"] = list(self.class_decorators)
         return d
 
     def to_content_blob(self) -> dict[str, Any]:
@@ -86,6 +95,12 @@ def to_content_blob(self) -> dict[str, Any]:
             blob["module_vars"] = dict(self.module_vars)
         if self.class_bases:
             blob["class_bases"] = list(self.class_bases)
+        if self.class_keywords:
+            blob["class_keywords"] = dict(self.class_keywords)
+        if self.class_attrs:
+            blob["class_attrs"] = list(self.class_attrs)
+        if self.class_decorators:
+            blob["class_decorators"] = list(self.class_decorators)
         return blob
 
     def content_hash(self) -> str:
@@ -107,6 +122,9 @@ def content_hash(self) -> str:
             "closure_func_refs": dict(sorted(self.closure_func_refs.items())),
             "module_vars": dict(sorted(self.module_vars.items())),
             "class_bases": list(self.class_bases),
+            "class_keywords": dict(sorted(self.class_keywords.items())),
+            "class_attrs": list(self.class_attrs),
+            "class_decorators": list(self.class_decorators),
         }
         raw = json.dumps(canonical, sort_keys=True, separators=(",", ":"))
         return hashlib.sha256(raw.encode("utf-8")).hexdigest()[:16]
@@ -125,4 +143,7 @@ def from_dict(cls, data: dict[str, Any]) -> Self:
             closure_func_refs=data.get("closure_func_refs", {}),
             module_vars=data.get("module_vars", {}),
             class_bases=data.get("class_bases", []),
+            class_keywords=data.get("class_keywords", {}),
+            class_attrs=data.get("class_attrs", []),
+            class_decorators=data.get("class_decorators", []),
         )

pyfuse/core/version.py

@@ -1 +1 @@
-_VERSION = "0.3.0"
+_VERSION = "0.4.0"

pyfuse/graph/analyzer.py

@@ -212,27 +212,65 @@ def has_super_call(func_source: str) -> bool:
     return False
 
 
-def get_class_bases_from_source(cls: type) -> list[str]:
-    """Extract base class names from the class definition source AST.
-
-    Returns simple base class names (not fully qualified). Skips ``object``
-    since it's implicit.
+def get_class_bases_from_source(
+    cls: type,
+) -> tuple[list[str], dict[str, str]]:
+    """Extract base class names and keyword arguments from the class definition.
+
+    Returns ``(bases, keywords)`` where *bases* is a list of base class names
+    (excluding ``object``) and *keywords* maps keyword names to their unparsed
+    AST values (e.g. ``{"metaclass": "ABCMeta"}``).
     """
     try:
         source = textwrap.dedent(inspect.getsource(cls))
     except (OSError, TypeError):
-        return []
+        return [], {}
     try:
         tree = ast.parse(source)
     except SyntaxError:
-        return []
+        return [], {}
     for node in tree.body:
         if isinstance(node, ast.ClassDef) and node.name == cls.__name__:
-            bases: list[str] = []
-            for base in node.bases:
-                bases.append(ast.unparse(base))
-            return [b for b in bases if b != "object"]
-    return []
+            bases = [ast.unparse(b) for b in node.bases if ast.unparse(b) != "object"]
+            keywords: dict[str, str] = {}
+            for kw in node.keywords:
+                if kw.arg is not None:
+                    keywords[kw.arg] = ast.unparse(kw.value)
+            return bases, keywords
+    return [], {}
+
+
+def get_class_attrs(cls: type) -> tuple[list[str], list[str]]:
+    """Extract class-level attributes and decorators from the class source AST.
+
+    Returns ``(attrs, decorators)`` where *attrs* is a list of source code
+    strings for class body statements (assignments, annotated assignments,
+    docstrings) and *decorators* is a list of decorator source strings
+    (without the ``@`` prefix).
+    """
+    try:
+        source = textwrap.dedent(inspect.getsource(cls))
+    except (OSError, TypeError):
+        return [], []
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return [], []
+    for node in tree.body:
+        if not (isinstance(node, ast.ClassDef) and node.name == cls.__name__):
+            continue
+        attrs: list[str] = []
+        for child in node.body:
+            if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                continue
+            segment = ast.get_source_segment(source, child)
+            if segment is not None:
+                attrs.append(textwrap.dedent(segment))
+            else:
+                attrs.append(ast.unparse(child))
+        decorators = [ast.unparse(d) for d in node.decorator_list]
+        return attrs, decorators
+    return [], []
 
 
 def find_bare_calls(func_source: str) -> set[str]: