Add typing to component init

MANIFEST.in

@@ -12,3 +12,4 @@ include dash/dash-renderer/build/*.js
 include dash/dash-renderer/build/*.map
 include dash/labextension/dist/dash-jupyterlab.tgz
 include dash/labextension/package.json
+include dash/py.typed

dash/_callback.py

@@ -1,14 +1,15 @@
 import collections
 import hashlib
 from functools import wraps
-from typing import Callable, Optional, Any
+from typing import Callable, Optional, Any, List, Tuple
 
 import flask
 
 from .dependencies import (
     handle_callback_args,
     handle_grouped_callback_args,
     Output,
+    Input,
 )
 from .exceptions import (
     InvalidCallbackReturnValue,
@@ -60,14 +61,14 @@ def is_no_update(obj):
 # pylint: disable=too-many-locals
 def callback(
     *_args,
-    background=False,
-    interval=1000,
-    progress=None,
-    progress_default=None,
-    running=None,
-    cancel=None,
-    manager=None,
-    cache_args_to_ignore=None,
+    background: bool = False,
+    interval: int = 1000,
+    progress: Optional[Output] = None,
+    progress_default: Any = None,
+    running: Optional[List[Tuple[Output, Any, Any]]] = None,
+    cancel: Optional[List[Input]] = None,
+    manager: Optional[BaseLongCallbackManager] = None,
+    cache_args_to_ignore: Optional[list] = None,
     on_error: Optional[Callable[[Exception], Any]] = None,
     **_kwargs,
 ):
@@ -154,7 +155,7 @@ def callback(
     callback_list = _kwargs.pop("callback_list", GLOBAL_CALLBACK_LIST)
 
     if background:
-        long_spec = {
+        long_spec: Any = {
             "interval": interval,
         }
 

dash/development/_py_components_generation.py

@@ -1,16 +1,20 @@
 from collections import OrderedDict
 import copy
+import numbers
 import os
+import typing
 from textwrap import fill, dedent
 
+from typing_extensions import TypedDict, NotRequired, Literal
 from dash.development.base_component import _explicitize_args
 from dash.exceptions import NonExistentEventException
 from ._all_keywords import python_keywords
 from ._collect_nodes import collect_nodes, filter_base_nodes
-from .base_component import Component
+from ._py_prop_typing import get_prop_typing, shapes, custom_imports
+from .base_component import Component, ComponentType
 
 
-# pylint: disable=unused-argument,too-many-locals
+# pylint: disable=unused-argument,too-many-locals,too-many-branches
 def generate_class_string(
     typename,
     props,
@@ -54,8 +58,12 @@ def generate_class_string(
     _base_nodes = {base_nodes}
     _namespace = '{namespace}'
     _type = '{typename}'
+{shapes}
     @_explicitize_args
-    def __init__(self, {default_argtext}):
+    def __init__(
+        self,
+        {default_argtext}
+    ):
         self._prop_names = {list_of_valid_keys}
         self._valid_wildcard_attributes =\
             {list_of_valid_wildcard_attr_prefixes}
@@ -94,7 +102,9 @@ def __init__(self, {default_argtext}):
     prop_keys = list(props.keys())
     if "children" in props and "children" in list_of_valid_keys:
         prop_keys.remove("children")
-        default_argtext = "children=None, "
+        # TODO For dash 3.0, remove the Optional and = None for proper typing.
+        #  Also add the other required props after children.
+        default_argtext = f"children: typing.Optional[{get_prop_typing('node', '', '', {})}] = None,\n        "
         args = "{k: _locals[k] for k in _explicit_args if k != 'children'}"
         argtext = "children=children, **args"
     else:
@@ -118,15 +128,31 @@ def __init__(self, {default_argtext}):
             raise TypeError('Required argument children was not specified.')
         """
 
-    default_arglist = [
-        (
-            f"{p:s}=Component.REQUIRED"
-            if props[p]["required"]
-            else f"{p:s}=Component.UNDEFINED"
-        )
-        for p in prop_keys
-        if not p.endswith("-*") and p not in python_keywords and p != "setProps"
-    ]
+    default_arglist = []
+
+    for prop_key in prop_keys:
+        prop = props[prop_key]
+        if (
+            prop_key.endswith("-*")
+            or prop_key in python_keywords
+            or prop_key == "setProps"
+        ):
+            continue
+
+        type_info = prop.get("type")
+
+        if not type_info:
+            print(f"Invalid prop type for typing: {prop_key}")
+            default_arglist.append(f"{prop_key} = None")
+            continue
+
+        type_name = type_info.get("name")
+
+        typed = get_prop_typing(type_name, typename, prop_key, type_info, namespace)
+
+        arg_value = f"{prop_key}: typing.Optional[{typed}] = None"
+
+        default_arglist.append(arg_value)
 
     if max_props:
         final_max_props = max_props - (1 if "children" in props else 0)
@@ -139,7 +165,7 @@ def __init__(self, {default_argtext}):
                 "they may still be used as keyword arguments."
             )
 
-    default_argtext += ", ".join(default_arglist + ["**kwargs"])
+    default_argtext += ",\n        ".join(default_arglist + ["**kwargs"])
     nodes = collect_nodes({k: v for k, v in props.items() if k != "children"})
 
     return dedent(
@@ -156,6 +182,7 @@ def __init__(self, {default_argtext}):
             required_validation=required_validation,
             children_props=nodes,
             base_nodes=filter_base_nodes(nodes) + ["children"],
+            shapes="\n".join(shapes.get(typename, {}).values()),
         )
     )
 
@@ -181,13 +208,23 @@ def generate_class_file(
     """
     import_string = (
         "# AUTO GENERATED FILE - DO NOT EDIT\n\n"
-        + "from dash.development.base_component import "
-        + "Component, _explicitize_args\n\n\n"
+        "import typing  # noqa: F401\n"
+        "import numbers # noqa: F401\n"
+        "from typing_extensions import TypedDict, NotRequired, Literal # noqa: F401\n"
+        "from dash.development.base_component import ComponentType # noqa: F401\n"
+        "from dash.development.base_component import "
+        "Component, _explicitize_args\n\n\n"
     )
 
     class_string = generate_class_string(
         typename, props, description, namespace, prop_reorder_exceptions, max_props
     )
+
+    custom_imp = custom_imports[namespace][typename]
+    if custom_imp:
+        import_string += "\n".join(custom_imp)
+        import_string += "\n\n"
+
     file_name = f"{typename:s}.py"
 
     file_path = os.path.join(namespace, file_name)
@@ -242,7 +279,16 @@ def generate_class(
     string = generate_class_string(
         typename, props, description, namespace, prop_reorder_exceptions
     )
-    scope = {"Component": Component, "_explicitize_args": _explicitize_args}
+    scope = {
+        "Component": Component,
+        "ComponentType": ComponentType,
+        "_explicitize_args": _explicitize_args,
+        "typing": typing,
+        "numbers": numbers,
+        "TypedDict": TypedDict,
+        "NotRequired": NotRequired,
+        "Literal": Literal,
+    }
     # pylint: disable=exec-used
     exec(string, scope)
     result = scope[typename]

dash/development/_py_prop_typing.py

@@ -0,0 +1,170 @@
+import collections
+import json
+import string
+import textwrap
+
+import stringcase
+
+
+shapes = {}
+shape_template = """{name} = TypedDict(
+    "{name}",
+    {values}
+)
+"""
+custom_imports = collections.defaultdict(lambda: collections.defaultdict(list))
+
+
+def _clean_key(key):
+    k = ""
+    for ch in key:
+        if ch not in string.ascii_letters + "_":
+            k += "_"
+        else:
+            k += ch
+    return k
+
+
+def generate_any(*_):
+    return "typing.Any"
+
+
+def generate_shape(type_info, component_name: str, prop_name: str):
+    props = []
+    name = stringcase.pascalcase(prop_name)
+
+    for prop_key, prop_type in type_info["value"].items():
+        typed = get_prop_typing(
+            prop_type["name"], component_name, f"{prop_name}_{prop_key}", prop_type
+        )
+        if not prop_type.get("required"):
+            props.append(f'        "{prop_key}": NotRequired[{typed}]')
+        else:
+            props.append(f'        "{prop_key}": {typed}')
+
+    shapes.setdefault(component_name, {})
+    shapes[component_name][name] = textwrap.indent(
+        shape_template.format(
+            name=name, values="    {\n" + ",\n".join(props) + "\n    }"
+        ),
+        "    ",
+    )
+
+    return f'"{name}"'
+
+
+def generate_union(type_info, component_name: str, prop_name: str):
+    types = []
+    for union in type_info["value"]:
+        u_type = get_prop_typing(union["name"], component_name, prop_name, union)
+        if u_type not in types:
+            types.append(u_type)
+    return f"typing.Union[{', '.join(types)}]"
+
+
+def generate_tuple(
+    type_info,
+    component_name: str,
+    prop_name: str,
+):
+    els = type_info.get("elements")
+    elements = ", ".join(
+        get_prop_typing(x.get("name"), component_name, prop_name, x) for x in els
+    )
+    return f"typing.Tuple[{elements}]"
+
+
+def generate_array_of(
+    type_info,
+    component_name: str,
+    prop_name: str,
+):
+    typed = get_prop_typing(
+        type_info["value"]["name"], component_name, prop_name, type_info["value"]
+    )
+    return f"typing.Union[typing.Sequence[{typed}], typing.Tuple]"
+
+
+def generate_object_of(type_info, component_name: str, prop_name: str):
+    typed = get_prop_typing(
+        type_info["value"]["name"], component_name, prop_name, type_info["value"]
+    )
+    return f"typing.Dict[typing.Union[str, float, int], {typed}]"
+
+
+def generate_type(typename):
+    def type_handler(*_):
+        return typename
+
+    return type_handler
+
+
+def _get_literal_value(value):
+    if value is None:
+        return "None"
+
+    if isinstance(value, bool):
+        return str(value)
+
+    return json.dumps(value)
+
+
+def generate_enum(type_info, *_):
+    values = [
+        _get_literal_value(json.loads(v["value"].replace("'", '"')))
+        for v in type_info["value"]
+        if v
+    ]
+    return f"Literal[{', '.join(values)}]"
+
+
+def get_prop_typing(
+    type_name: str, component_name: str, prop_name: str, type_info, namespace=None
+):
+    if namespace:
+        # Only check the namespace once
+        special = (
+            special_cases.get(namespace, {}).get(component_name, {}).get(prop_name)
+        )
+        if special:
+            return special(type_info, component_name, prop_name)
+
+    prop_type = PROP_TYPING.get(type_name, generate_any)(
+        type_info, component_name, prop_name
+    )
+    return prop_type
+
+
+def generate_plotly_figure(*_):
+    custom_imports["dash_core_components"]["Graph"].append(
+        "from plotly.graph_objects import Figure"
+    )
+    return "typing.Union[Figure, dict]"
+
+
+special_cases = {"dash_core_components": {"Graph": {"figure": generate_plotly_figure}}}
+
+
+PROP_TYPING = {
+    "array": generate_type("typing.Union[typing.Sequence, typing.Tuple]"),
+    "arrayOf": generate_array_of,
+    "object": generate_type("dict"),
+    "shape": generate_shape,
+    "exact": generate_shape,
+    "string": generate_type("str"),
+    "bool": generate_type("bool"),
+    "number": generate_type("typing.Union[int, float, numbers.Number]"),
+    "node": generate_type(
+        "typing.Union[str, int, float, ComponentType,"
+        " typing.Sequence[typing.Union"
+        "[str, int, float, ComponentType]]]"
+    ),
+    "func": generate_any,
+    "element": generate_type("ComponentType"),
+    "union": generate_union,
+    "any": generate_any,
+    "custom": generate_any,
+    "enum": generate_enum,
+    "objectOf": generate_object_of,
+    "tuple": generate_tuple,
+}