Update Modules/_docstrings.py

Modules/_docstrings.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import ast
 import inspect
 import sys
 import types
@@ -41,6 +42,43 @@ def _extract_base_and_meta(annotation: Any) -> tuple[Any, str | None]:
         return annotation, None
 
 
+def _parse_annotated_string(annot_str: str) -> tuple[str, str | None]:
+    """Fallback: parse 'Annotated[Type, "desc"]' string using AST."""
+    try:
+        expr = ast.parse(annot_str, mode='eval').body
+        if isinstance(expr, ast.Subscript):
+            val = expr.value
+            is_annotated = False
+            if isinstance(val, ast.Name) and val.id == 'Annotated':
+                is_annotated = True
+            elif isinstance(val, ast.Attribute) and val.attr == 'Annotated':
+                is_annotated = True
+            
+            if is_annotated:
+                sl = expr.slice
+                # In 3.9+, slice is the node. In <3.9, it might be Index/ExtSlice.
+                if isinstance(sl, ast.Tuple):
+                    elts = sl.elts
+                    if len(elts) >= 2:
+                        # elts[0] is type, elts[1] is metadata
+                        meta_node = elts[1]
+                        desc = None
+                        if isinstance(meta_node, ast.Constant) and isinstance(meta_node.value, str):
+                            desc = meta_node.value
+                        elif isinstance(meta_node, ast.Str):
+                            desc = meta_node.s
+                        
+                        if desc:
+                            if hasattr(ast, 'unparse'):
+                                type_str = ast.unparse(elts[0])
+                            else:
+                                type_str = "Any"
+                            return type_str, desc
+    except Exception:
+        pass
+    return annot_str, None
+
+
 def autodoc(summary: str | None = None, returns: str | None = None, *, force: bool = False):
     """
     Decorator that auto-generates a concise Google-style docstring from a function's
@@ -73,7 +111,15 @@ def autodoc(summary: str | None = None, returns: str | None = None, *, force: bo
             for name, param in sig.parameters.items():
                 if isinstance(param.annotation, str):
                     try:
-                        val = eval(param.annotation, getattr(func, "__globals__", {}))
+                        # Ensure typing is available in eval context
+                        globs = getattr(func, "__globals__", {}).copy()
+                        import typing
+                        globs['typing'] = typing
+                        for t in ['Annotated', 'Literal', 'Optional', 'Union', 'List', 'Dict', 'Any']:
+                            if t not in globs:
+                                globs[t] = getattr(typing, t)
+                        
+                        val = eval(param.annotation, globs)
                         hints[name] = val
                     except Exception:
                         pass
@@ -98,7 +144,16 @@ def autodoc(summary: str | None = None, returns: str | None = None, *, force: bo
                 if name == "self":
                     continue
                 annot = hints.get(name, param.annotation)
+                
                 base, meta = _extract_base_and_meta(annot)
+                
+                # If meta is missing and annot is a string, try AST fallback
+                if meta is None and isinstance(annot, str):
+                    base_str, meta_str = _parse_annotated_string(annot)
+                    if meta_str:
+                        base = base_str
+                        meta = meta_str
+
                 tname = _typename(base) if base is not inspect._empty else None
                 desc = meta or ""
                 if tname and tname != str(inspect._empty):
@@ -127,4 +182,4 @@ def autodoc(summary: str | None = None, returns: str | None = None, *, force: bo
     return decorator
 
 
-__all__ = ["autodoc"]
+__all__ = ["autodoc"]