| """Contains methods that generate documentation for Gradio functions and classes.""" |
|
|
| from __future__ import annotations |
|
|
| import inspect |
| from typing import Callable |
|
|
| classes_to_document = {} |
| classes_inherit_documentation = {} |
| documentation_group = None |
|
|
|
|
| def set_documentation_group(m): |
| global documentation_group |
| documentation_group = m |
| if m not in classes_to_document: |
| classes_to_document[m] = [] |
|
|
|
|
| def extract_instance_attr_doc(cls, attr): |
| code = inspect.getsource(cls.__init__) |
| lines = [line.strip() for line in code.split("\n")] |
| i = None |
| for i, line in enumerate(lines): |
| if line.startswith("self." + attr + ":") or line.startswith( |
| "self." + attr + " =" |
| ): |
| break |
| assert i is not None, f"Could not find {attr} in {cls.__name__}" |
| start_line = lines.index('"""', i) |
| end_line = lines.index('"""', start_line + 1) |
| for j in range(i + 1, start_line): |
| assert not lines[j].startswith("self."), ( |
| f"Found another attribute before docstring for {attr} in {cls.__name__}: " |
| + lines[j] |
| + "\n start:" |
| + lines[i] |
| ) |
| doc_string = " ".join(lines[start_line + 1 : end_line]) |
| return doc_string |
|
|
|
|
| def document(*fns, inherit=False): |
| """ |
| Defines the @document decorator which adds classes or functions to the Gradio |
| documentation at www.gradio.app/docs. |
| |
| Usage examples: |
| - Put @document() above a class to document the class and its constructor. |
| - Put @document("fn1", "fn2") above a class to also document methods fn1 and fn2. |
| - Put @document("*fn3") with an asterisk above a class to document the instance attribute methods f3. |
| """ |
|
|
| def inner_doc(cls): |
| global documentation_group |
| if inherit: |
| classes_inherit_documentation[cls] = None |
| classes_to_document[documentation_group].append((cls, fns)) |
| return cls |
|
|
| return inner_doc |
|
|
|
|
| def document_fn(fn: Callable, cls) -> tuple[str, list[dict], dict, str | None]: |
| """ |
| Generates documentation for any function. |
| Parameters: |
| fn: Function to document |
| Returns: |
| description: General description of fn |
| parameters: A list of dicts for each parameter, storing data for the parameter name, annotation and doc |
| return: A dict storing data for the returned annotation and doc |
| example: Code for an example use of the fn |
| """ |
| doc_str = inspect.getdoc(fn) or "" |
| doc_lines = doc_str.split("\n") |
| signature = inspect.signature(fn) |
| description, parameters, returns, examples = [], {}, [], [] |
| mode = "description" |
| for line in doc_lines: |
| line = line.rstrip() |
| if line == "Parameters:": |
| mode = "parameter" |
| elif line.startswith("Example:"): |
| mode = "example" |
| if "(" in line and ")" in line: |
| c = line.split("(")[1].split(")")[0] |
| if c != cls.__name__: |
| mode = "ignore" |
| elif line == "Returns:": |
| mode = "return" |
| else: |
| if mode == "description": |
| description.append(line if line.strip() else "<br>") |
| continue |
| if not (line.startswith(" ") or line.strip() == ""): |
| print(line) |
| assert ( |
| line.startswith(" ") or line.strip() == "" |
| ), f"Documentation format for {fn.__name__} has format error in line: {line}" |
| line = line[4:] |
| if mode == "parameter": |
| colon_index = line.index(": ") |
| assert ( |
| colon_index > -1 |
| ), f"Documentation format for {fn.__name__} has format error in line: {line}" |
| parameter = line[:colon_index] |
| parameter_doc = line[colon_index + 2 :] |
| parameters[parameter] = parameter_doc |
| elif mode == "return": |
| returns.append(line) |
| elif mode == "example": |
| examples.append(line) |
| description_doc = " ".join(description) |
| parameter_docs = [] |
| for param_name, param in signature.parameters.items(): |
| if param_name.startswith("_"): |
| continue |
| if param_name in ["kwargs", "args"] and param_name not in parameters: |
| continue |
| parameter_doc = { |
| "name": param_name, |
| "annotation": param.annotation, |
| "doc": parameters.get(param_name), |
| } |
| if param_name in parameters: |
| del parameters[param_name] |
| if param.default != inspect.Parameter.empty: |
| default = param.default |
| if type(default) == str: |
| default = '"' + default + '"' |
| if default.__class__.__module__ != "builtins": |
| default = f"{default.__class__.__name__}()" |
| parameter_doc["default"] = default |
| elif parameter_doc["doc"] is not None: |
| if "kwargs" in parameter_doc["doc"]: |
| parameter_doc["kwargs"] = True |
| if "args" in parameter_doc["doc"]: |
| parameter_doc["args"] = True |
| parameter_docs.append(parameter_doc) |
| assert ( |
| len(parameters) == 0 |
| ), f"Documentation format for {fn.__name__} documents nonexistent parameters: {''.join(parameters.keys())}" |
| if len(returns) == 0: |
| return_docs = {} |
| elif len(returns) == 1: |
| return_docs = {"annotation": signature.return_annotation, "doc": returns[0]} |
| else: |
| return_docs = {} |
| |
| examples_doc = "\n".join(examples) if len(examples) > 0 else None |
| return description_doc, parameter_docs, return_docs, examples_doc |
|
|
|
|
| def document_cls(cls): |
| doc_str = inspect.getdoc(cls) |
| if doc_str is None: |
| return "", {}, "" |
| tags = {} |
| description_lines = [] |
| mode = "description" |
| for line in doc_str.split("\n"): |
| line = line.rstrip() |
| if line.endswith(":") and " " not in line: |
| mode = line[:-1].lower() |
| tags[mode] = [] |
| elif line.split(" ")[0].endswith(":") and not line.startswith(" "): |
| tag = line[: line.index(":")].lower() |
| value = line[line.index(":") + 2 :] |
| tags[tag] = value |
| else: |
| if mode == "description": |
| description_lines.append(line if line.strip() else "<br>") |
| else: |
| assert ( |
| line.startswith(" ") or not line.strip() |
| ), f"Documentation format for {cls.__name__} has format error in line: {line}" |
| tags[mode].append(line[4:]) |
| if "example" in tags: |
| example = "\n".join(tags["example"]) |
| del tags["example"] |
| else: |
| example = None |
| for key, val in tags.items(): |
| if isinstance(val, list): |
| tags[key] = "<br>".join(val) |
| description = " ".join(description_lines).replace("\n", "<br>") |
| return description, tags, example |
|
|
|
|
| def generate_documentation(): |
| documentation = {} |
| for mode, class_list in classes_to_document.items(): |
| documentation[mode] = [] |
| for cls, fns in class_list: |
| fn_to_document = cls if inspect.isfunction(cls) else cls.__init__ |
| _, parameter_doc, return_doc, _ = document_fn(fn_to_document, cls) |
| cls_description, cls_tags, cls_example = document_cls(cls) |
| cls_documentation = { |
| "class": cls, |
| "name": cls.__name__, |
| "description": cls_description, |
| "tags": cls_tags, |
| "parameters": parameter_doc, |
| "returns": return_doc, |
| "example": cls_example, |
| "fns": [], |
| } |
| for fn_name in fns: |
| instance_attribute_fn = fn_name.startswith("*") |
| if instance_attribute_fn: |
| fn_name = fn_name[1:] |
| |
| |
| fn = getattr(cls(), fn_name).__call__ |
| else: |
| fn = getattr(cls, fn_name) |
| if not callable(fn): |
| description_doc = str(fn) |
| parameter_docs = {} |
| return_docs = {} |
| examples_doc = "" |
| override_signature = f"gr.{cls.__name__}.{fn_name}" |
| else: |
| ( |
| description_doc, |
| parameter_docs, |
| return_docs, |
| examples_doc, |
| ) = document_fn(fn, cls) |
| override_signature = None |
| if instance_attribute_fn: |
| description_doc = extract_instance_attr_doc(cls, fn_name) |
| cls_documentation["fns"].append( |
| { |
| "fn": fn, |
| "name": fn_name, |
| "description": description_doc, |
| "tags": {}, |
| "parameters": parameter_docs, |
| "returns": return_docs, |
| "example": examples_doc, |
| "override_signature": override_signature, |
| } |
| ) |
| documentation[mode].append(cls_documentation) |
| if cls in classes_inherit_documentation: |
| classes_inherit_documentation[cls] = cls_documentation["fns"] |
| for mode, class_list in classes_to_document.items(): |
| for i, (cls, _) in enumerate(class_list): |
| for super_class in classes_inherit_documentation: |
| if ( |
| inspect.isclass(cls) |
| and issubclass(cls, super_class) |
| and cls != super_class |
| ): |
| for inherited_fn in classes_inherit_documentation[super_class]: |
| inherited_fn = dict(inherited_fn) |
| try: |
| inherited_fn["description"] = extract_instance_attr_doc( |
| cls, inherited_fn["name"] |
| ) |
| except (ValueError, AssertionError): |
| pass |
| documentation[mode][i]["fns"].append(inherited_fn) |
| return documentation |
|
|
