Update Modules/_docstrings.py

Modules/_docstrings.py

@@ -1,22 +1,12 @@
 from __future__ import annotations
 
-import ast
 import inspect
-import sys
-import types
-from typing import Any, Annotated, get_args, get_origin, get_type_hints, Union
+from typing import Any, Annotated, get_args, get_origin, get_type_hints
 
 
 def _typename(tp: Any) -> str:
     """Return a readable type name from a type or annotation."""
     try:
-        # Unwrap Optional[T] -> T
-        origin = get_origin(tp)
-        if origin is Union or (sys.version_info >= (3, 10) and origin is types.UnionType):
-            args = [a for a in get_args(tp) if a is not type(None)]
-            if len(args) == 1:
-                return _typename(args[0])
-
         if hasattr(tp, "__name__"):
             return tp.__name__  # e.g. int, str
         if getattr(tp, "__module__", None) and getattr(tp, "__qualname__", None):
@@ -42,43 +32,6 @@ 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
@@ -105,24 +58,7 @@ def autodoc(summary: str | None = None, returns: str | None = None, *, force: bo
             # include_extras=True to retain Annotated metadata
             hints = get_type_hints(func, include_extras=True, globalns=getattr(func, "__globals__", None))
         except Exception:
-            # Fallback: try to evaluate annotations manually if they are strings
             hints = {}
-            sig = inspect.signature(func)
-            for name, param in sig.parameters.items():
-                if isinstance(param.annotation, str):
-                    try:
-                        # 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
 
         sig = inspect.signature(func)
 
@@ -144,16 +80,7 @@ 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):