Python Docstring Extractor

Copy[project.scripts]
fumapy-generate = "fumapy:generate"

Copy    extensions = griffe.load_extensions(TypingDocExtension)
    pkg = parse_module(
        griffe.load(
            args.module, docstring_parser="auto", store_source=STORE_SOURCE, extensions=extensions
        )
    )
    api_filename = f"{args.module}.json"
 
    with open(os.path.join(args.dir, api_filename), "w") as file:
        json.dump(pkg, file, cls=CustomEncoder, indent=2, full=True)

Copydef parse_module(m: griffe.Object) -> Module:
    if not isinstance(m, griffe.Module):
        raise ValueError("Module must be a module")
 
    out = simplify_docstring(m.docstring, m)
    res: Module = {
        "name": m.name,
        "path": m.path,
        "filepath": m.filepath,
        "description": out.description,
        "docstring": out.remainder,
        "attributes": out.attributes,
        "modules": {
            name: parse_module(value)
            for name, value in m.modules.items()
            if not value.is_alias
        },
        "classes": {
            name: parse_class(value)
            for name, value in m.classes.items()
            if not value.is_alias
        },
        "functions": {
            name: parse_function(value)
            for name, value in m.functions.items()
            if not value.is_alias
        },
    }
    if m.is_package:
        try:
            res["version"] = version(m.name)
        except AttributeError:
            res["version"] = "unknown"
 
    return res

Copydef parse_class(c: griffe.Class) -> Class:
    out = simplify_docstring(c.docstring, c)
    res: Class = {
        "name": c.name,
        "path": c.path,
        "description": out.description,
        "parameters": out.parameters,
        "attributes": out.attributes,
        "docstring": out.remainder,
        "functions": {
            name: parse_function(value)
            for name, value in c.functions.items()
            if not value.is_alias
        },
        "source": c.source,
        "inherited_members": {},
    }
    for member in c.inherited_members.values():
        parent_path = ".".join(member.canonical_path.split(".")[:-1])
        member_info = {"kind": member.kind, "path": member.canonical_path}
        if parent_path not in res["inherited_members"]:
            res["inherited_members"][parent_path] = []
        res["inherited_members"][parent_path].append(member_info)
    return res

Copydef parse_function(f: griffe.Function) -> Function:
    out = simplify_docstring(f.docstring, f)
    res: Function = {
        "name": f.name,
        "path": f.path,
        "signature": build_signature(f),
        "description": out.description,
        "parameters": out.parameters,
        "returns": out.returns,
        "docstring": out.remainder,
        "source": f.source,
    }
    return res

Copyclass SimplifiedDocstring(t.NamedTuple):
    description: str | None
    parameters: list[dict[str, str | None]]
    returns: dict[str, str | None]
    attributes: list[dict[str, str | None]]
    remainder: list[griffe.DocstringSection]
 

Copydef get_parameters_from_signature(parent: griffe.Class | griffe.Function):
    return [
        {
            "name": p.name,
            "annotation": p.annotation,
            "description": None,
            "value": p.default,
        }
        for p in parent.parameters
    ]
 
def get_returns_from_signature(parent: griffe.Function):
    return {
        "name": "",
        "annotation": (
            parent.returns
            if isinstance(parent.returns, (str, type(None)))
            else "".join(
                elem if isinstance(elem, str) else elem.canonical_path
                for elem in parent.returns.iterate(flat=True)
            )
        ),
        "description": None,
    }
 
def get_attributes_from_signature(parent: griffe.Module | griffe.Class):
    return [
        {
            "name": attr.name,
            "annotation": attr.annotation,
            "description": attr.docstring.parsed if attr.docstring else None,
            "value": attr.value,
        }
        for attr in parent.attributes.values()
        if (not attr.is_alias and not attr.is_private)
    ]

Copyfor i, sec in enumerate(doc.parsed):
    if sec.kind == "text" and i == 0:
        description = sec.value
        continue
 
    # Sort the parameters with the real signature
    if sec.kind == "parameters":
        map = {i.name: i for i in sec.value}
        params_list = []
        for param in parent.parameters:
            if param.name in map:
                docstring = map[param.name]
                try:
                    docstring.description = griffe.parse_google(
                        griffe.Docstring(docstring.description)
                    )
                except AttributeError:
                    pass
                params_list.append(docstring)
            else:
                params_list.append(
                    {
                        "name": param.name,
                        "annotation": param.annotation,
                        "description": None,
                        "value": param.default,
                    }
                )
 
        parameters = params_list
        continue
 
    if sec.kind == "returns":
        returns: griffe.DocstringReturn = sec.value[0]
        returns.annotation = (
            returns.annotation.canonical_path
            if isinstance(returns.annotation, griffe.Expr)
            else returns.annotation
        )
        continue

Copyclass Module(t.TypedDict):
    name: str
    path: str
    filepath: str
    description: str | None
    docstring: Docstring
    attributes: list[Attribute]
    modules: dict[str, Module]
    classes: dict[str, Class]
    functions: dict[str, Function]
    version: str | None
 
 
class Class(t.TypedDict):
    name: str
    path: str
    description: str | None
    parameters: list[Parameter]
    attributes: list[Attribute]
    docstring: Docstring
    functions: dict[str, Function]
    source: str
 
 
class Function(t.TypedDict):
    name: str
    path: str
    signature: str
    description: str | None
    parameters: list[Parameter]
    returns: dict[str, str | None]
    docstring: Docstring
    source: str
 

Copy_json_encoder_map: dict[type, t.Callable[[t.Any], t.Any]] = {
    Path: str,
    PosixPath: str,
    WindowsPath: str,
    set: sorted,
}

Copyclass CustomEncoder(griffe.JSONEncoder):
    def default(self, obj: t.Any) -> t.Any:
        """Return a serializable representation of the given object.
 
        Parameters:
            obj: The object to serialize.
 
        Returns:
            A serializable representation.
        """
 
        try:
            if isinstance(obj, griffe.Expr):
                return str(obj)
            return obj.as_dict(full=self.full)
        except AttributeError:
            return _json_encoder_map.get(type(obj), super().default)(obj)

Copyconst cardVariants = cva('bg-fd-card rounded-lg text-sm my-6 p-3 border');
const badgeVariants = cva('text-xs font-medium border p-1 rounded-lg not-prose', {
  variants: {
    color: {
      func: 'bg-fdpy-func/10 text-fdpy-func border-fdpy-func/50',
      attribute: 'bg-fdpy-attribute/10 text-fdpy-attribute border-fdpy-attribute/50',
      class: 'bg-fdpy-class/10 text-fdpy-class border-fdpy-class/50',
      primary: 'bg-fd-primary/10 text-fd-primary border-fd-primary/10',
    },
  },
});

Copyexport function PySourceCode({ children }: { children: ReactNode }) {
  return (
    <Collapsible className="my-6">
      <CollapsibleTrigger
        className={cn(
          buttonVariants({
            color: 'secondary',
            size: 'sm',
            className: 'group',
          }),
        )}
      >
        Source Code
        <ChevronRight className="size-3.5 text-fd-muted-foreground group-data-[state=open]:rotate-90" />
      </CollapsibleTrigger>
      <CollapsibleContent className="prose-no-margin">{children}</CollapsibleContent>
    </Collapsible>
  );
}