Add typing to component init

dash/development/_py_components_generation.py

@@ -1,16 +1,18 @@
 from collections import OrderedDict
 import copy
 import os
+import typing
 from textwrap import fill, dedent
 
 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 ._py_prop_typing import get_prop_typing
 from .base_component import Component
 
 
-# pylint: disable=unused-argument,too-many-locals
+# pylint: disable=unused-argument,too-many-locals,too-many-branches
 def generate_class_string(
     typename,
     props,
@@ -55,7 +57,10 @@ def generate_class_string(
     _namespace = '{namespace}'
     _type = '{typename}'
     @_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 +99,7 @@ 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, "
+        default_argtext = f"children: {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 +123,33 @@ 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
+        required = prop.get("required")
+        type_info = prop.get("type")
+
+        default_value = "Component.REQUIRED" if required else "Component.UNDEFINED"
+
+        if not type_info:
+            print(f"Invalid prop type for typing: {prop_key}")
+            default_arglist.append(f"{prop_key} = {default_value}")
+            continue
+
+        type_name = type_info.get("name")
+
+        typed = get_prop_typing(type_name, type_info)
+
+        arg_value = f"{prop_key}: {typed} = {default_value}"
+
+        default_arglist.append(arg_value)
 
     if max_props:
         final_max_props = max_props - (1 if "children" in props else 0)
@@ -139,7 +162,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(
@@ -181,8 +204,9 @@ 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"
+        "from dash.development.base_component import "
+        "Component, _explicitize_args\n\n\n"
     )
 
     class_string = generate_class_string(
@@ -242,7 +266,11 @@ def generate_class(
     string = generate_class_string(
         typename, props, description, namespace, prop_reorder_exceptions
     )
-    scope = {"Component": Component, "_explicitize_args": _explicitize_args}
+    scope = {
+        "Component": Component,
+        "_explicitize_args": _explicitize_args,
+        "typing": typing,
+    }
     # pylint: disable=exec-used
     exec(string, scope)
     result = scope[typename]

dash/development/_py_prop_typing.py

@@ -0,0 +1,77 @@
+def generate_any(_):
+    return "typing.Any"
+
+
+def generate_shape(t):
+    props = []
+
+    for prop in t["value"].values():
+        prop_type = PROP_TYPING.get(prop["name"], generate_any)(prop)
+        if prop_type not in props:
+            props.append(prop_type)
+
+    if len(props) == 0:
+        return "typing.Any"
+
+    return f"typing.Dict[str, typing.Union[{', '.join(props)}]]"
+
+
+def generate_union(t):
+    types = []
+    for union in t["value"]:
+        u_type = PROP_TYPING.get(union["name"], generate_any)(union)
+        if u_type not in types:
+            types.append(u_type)
+    return f"typing.Union[{', '.join(types)}]"
+
+
+def generate_tuple(type_info):
+    els = type_info.get("elements")
+    elements = ", ".join(get_prop_typing(x.get("name"), x) for x in els)
+    return f"typing.Tuple[{elements}]"
+
+
+def generate_array_of(t):
+    typed = PROP_TYPING.get(t["value"]["name"], generate_any)(t["value"])
+    return f"typing.List[{typed}]"
+
+
+def generate_object_of(t):
+    typed = PROP_TYPING.get(t["value"]["name"], generate_any)(t["value"])
+    return f"typing.Dict[str, {typed}]"
+
+
+def generate_type(typename):
+    def type_handler(_):
+        return typename
+
+    return type_handler
+
+
+def get_prop_typing(type_name: str, type_info):
+    return PROP_TYPING.get(type_name, generate_any)(type_info)
+
+
+PROP_TYPING = {
+    "array": generate_type("typing.List"),
+    "arrayOf": generate_array_of,
+    "object": generate_type("typing.Dict"),
+    "shape": generate_shape,
+    "exact": generate_shape,
+    "string": generate_type("str"),
+    "bool": generate_type("bool"),
+    "number": generate_type("typing.Union[float, int]"),
+    "node": generate_type(
+        "typing.Union[str, int, float, Component,"
+        " typing.List[typing.Union"
+        "[str, int, float, Component]]]"
+    ),
+    "func": generate_any,
+    "element": generate_type("Component"),
+    "union": generate_union,
+    "any": generate_any,
+    "custom": generate_any,
+    "enum": generate_any,
+    "objectOf": generate_object_of,
+    "tuple": generate_tuple,
+}

dash/development/base_component.py

@@ -2,6 +2,7 @@
 import collections
 import inspect
 import sys
+import typing
 import uuid
 import random
 
@@ -71,6 +72,9 @@ class Component(metaclass=ComponentMeta):
     _children_props = []
     _base_nodes = ["children"]
 
+    _valid_wildcard_attributes: typing.List[str]
+    available_wildcard_properties: typing.List[str]
+
     class _UNDEFINED:
         def __repr__(self):
             return "undefined"

requires-ci.txt

@@ -24,3 +24,4 @@ pytest-sugar==0.9.4
 xlrd>=2.0.1;python_version>="3.8"
 xlrd<2;python_version<"3.8"
 pytest-rerunfailures
+pyright==1.1.276