Refactor validators

codegen/__init__.py

@@ -21,8 +21,9 @@
     build_from_imports_py,
 )
 from codegen.validators import (
-    write_validator_py,
-    write_data_validator_py,
+    get_data_validator_params,
+    get_validator_params,
+    write_validator_json,
     get_data_validator_instance,
 )
 
@@ -171,22 +172,27 @@ def perform_codegen(reformat=True):
         if node.is_compound and not isinstance(node, ElementDefaultsNode)
     ]
 
+    validator_params = {}
     # Write out validators
     # --------------------
     # # ### Layout ###
     for node in all_layout_nodes:
-        write_validator_py(outdir, node)
+        get_validator_params(node, validator_params)
 
     # ### Trace ###
     for node in all_trace_nodes:
-        write_validator_py(outdir, node)
+        get_validator_params(node, validator_params)
 
     # ### Frames ###
     for node in all_frame_nodes:
-        write_validator_py(outdir, node)
+        get_validator_params(node, validator_params)
 
     # ### Data (traces) validator ###
-    write_data_validator_py(outdir, base_traces_node)
+    get_data_validator_params(base_traces_node, validator_params)
+
+    # Write out the JSON data for the validators
+    os.makedirs(validators_pkgdir, exist_ok=True)
+    write_validator_json(outdir, validator_params)
 
     # Alls
     # ----
@@ -217,27 +223,6 @@ def perform_codegen(reformat=True):
         layout_array_nodes,
     )
 
-    # Write validator __init__.py files
-    # ---------------------------------
-    # ### Write __init__.py files for each validator package ###
-    validator_rel_class_imports = {}
-    for node in all_datatype_nodes:
-        if node.is_mapped:
-            continue
-        key = node.parent_path_parts
-        validator_rel_class_imports.setdefault(key, []).append(
-            f"._{node.name_property}.{node.name_validator_class}"
-        )
-
-    # Add Data validator
-    root_validator_pairs = validator_rel_class_imports[()]
-    root_validator_pairs.append("._data.DataValidator")
-
-    # Output validator __init__.py files
-    validators_pkg = opath.join(outdir, "validators")
-    for path_parts, rel_classes in validator_rel_class_imports.items():
-        write_init_py(validators_pkg, path_parts, [], rel_classes)
-
     # Write datatype __init__.py files
     # --------------------------------
     datatype_rel_class_imports = {}

codegen/datatypes.py

@@ -130,14 +130,11 @@ class {datatype_class}(_{node.name_base_datatype}):\n"""
 """
         )
 
-        subplot_validator_names = [n.name_validator_class for n in subplot_nodes]
-
-        validator_csv = ", ".join(subplot_validator_names)
         subplot_dict_str = (
             "{"
             + ", ".join(
-                f"'{subname}': {valname}"
-                for subname, valname in zip(subplot_names, subplot_validator_names)
+                f'"{subname}": ValidatorCache.get_validator("layout", "{subname}")'
+                for subname in subplot_names
             )
             + "}"
         )
@@ -153,7 +150,7 @@ def _subplotid_validators(self):
         -------
         dict
         \"\"\"
-        from plotly.validators.layout import ({validator_csv})
+        from plotly.validator_cache import ValidatorCache
 
         return {subplot_dict_str}
 

codegen/validators.py

@@ -1,118 +1,91 @@
 import os.path as opath
 from io import StringIO
+import json
 
 import _plotly_utils.basevalidators
 from codegen.utils import CAVEAT, PlotlyNode, TraceNode, write_source_py
 
 
-def build_validator_py(node: PlotlyNode):
+def get_validator_params(node: PlotlyNode, store: dict):
     """
-    Build validator class source code string for a datatype PlotlyNode
+    Get params for the validator instance for the supplied node
+    and add them to the store.
 
     Parameters
     ----------
     node : PlotlyNode
         The datatype node (node.is_datatype must evaluate to true) for which
-        to build the validator class
+        to build a validator class
+    store : dict
+        Dictionary to store the JSON data for the validator
     Returns
     -------
-    str
-        String containing source code for the validator class definition
+    None
     """
-
-    # Validate inputs
-    # ---------------
+    assert isinstance(store, dict)
     assert node.is_datatype
 
-    # Initialize
-    import_alias = "_bv"
-    buffer = StringIO()
-    buffer.write(CAVEAT)
-
-    # Imports
-    # -------
-    # ### Import package of the validator's superclass ###
-    import_str = ".".join(node.name_base_validator.split(".")[:-1])
-    buffer.write(f"import {import_str} as {import_alias}\n")
-
-    # Build Validator
-    # ---------------
-    # ### Get dict of validator's constructor params ###
-    params = node.get_validator_params()
-
-    # ### Write class definition ###
-    class_name = node.name_validator_class
+    raw_params = node.get_validator_params()
+    params = dict([(k, eval(v)) for k, v in raw_params.items()])
     superclass_name = node.name_base_validator.split(".")[-1]
-    buffer.write(
-        f"""
 
-class {class_name}({import_alias}.{superclass_name}):
-    def __init__(self, plotly_name={params['plotly_name']},
-                       parent_name={params['parent_name']},
-                       **kwargs):"""
-    )
+    key = ".".join(node.parent_path_parts + (node.name_property,))
+    store[key] = {"params": params, "superclass": superclass_name}
 
-    # ### Write constructor ###
-    buffer.write(
-        f"""
-        super().__init__(plotly_name, parent_name"""
-    )
-
-    # Write out remaining constructor parameters
-    for attr_name, attr_val in params.items():
-        if attr_name in ["plotly_name", "parent_name"]:
-            # plotly_name and parent_name are already handled
-            continue
-
-        buffer.write(
-            f""",
-                 {attr_name}=kwargs.pop('{attr_name}', {attr_val})"""
-        )
 
-    buffer.write(
-        f""",
-        **kwargs"""
-    )
+def get_data_validator_params(base_trace_node: TraceNode, store: dict):
+    """
+    Add a dict of constructor params for the DataValidator to the store.
 
-    buffer.write(")")
+    Parameters
+    ----------
+    base_trace_node : TraceNode
+        PlotlyNode that is the parent of all of the individual trace nodes
+    store : dict
+        Dictionary to store the JSON data for the validator
+    Returns
+    -------
+    None"""
+    assert isinstance(store, dict)
 
-    # ### Return buffer's string ###
-    return buffer.getvalue()
+    params = build_data_validator_params(base_trace_node)
+    store["data"] = {
+        "params": params,
+        "superclass": "BaseDataValidator",
+    }
 
 
-def write_validator_py(outdir, node: PlotlyNode):
+def write_validator_json(outdir, params: dict):
     """
-    Build validator source code and write to a file
+    Write out a JSON serialization of the validator arguments
+    for all validators (keyed by f"{parent_name}.{plotly_name})
+
+    Each validator has a "params": {kwargs} entry and
+    a "superclass": str to indicate the class to be instantiated
 
     Parameters
     ----------
     outdir : str
         Root outdir in which the validators package should reside
-    node : PlotlyNode
-        The datatype node (node.is_datatype must evaluate to true) for which
-        to build a validator class
+    params : dict
+        Dictionary to store the JSON data for the validator
     Returns
     -------
     None
     """
-    if node.is_mapped:
-        # No validator written for mapped nodes
-        # e.g. no validator for layout.title_font since ths is mapped to
-        # layout.title.font
-        return
+    import json
 
-    # Generate source code
-    # --------------------
-    validator_source = build_validator_py(node)
+    # Validate inputs
+    # ---------------
+    if not isinstance(params, dict):
+        raise ValueError("Expected params to be a dictionary")
 
     # Write file
     # ----------
-    # filepath = opath.join(outdir, "validators", *node.parent_path_parts, "__init__.py")
-    filepath = opath.join(
-        outdir, "validators", *node.parent_path_parts, "_" + node.name_property + ".py"
-    )
-
-    write_source_py(validator_source, filepath, leading_newlines=2)
+    filepath = opath.join(outdir, "validators", "_validators.json")
+    with open(filepath, "w") as f:
+        f.write(json.dumps(params, indent=4))
+        # f.write(str(params))
 
 
 def build_data_validator_params(base_trace_node: TraceNode):
@@ -131,78 +104,16 @@ def build_data_validator_params(base_trace_node: TraceNode):
     # Get list of trace nodes
     # -----------------------
     tracetype_nodes = base_trace_node.child_compound_datatypes
-
-    # Build class_map_repr string
-    # ---------------------------
-    # This is the repr-form of a dict from trace propert name string
-    # to the name of the trace datatype class in the graph_objs package.
-    buffer = StringIO()
-    buffer.write("{\n")
-    for i, tracetype_node in enumerate(tracetype_nodes):
-        sfx = "," if i < len(tracetype_nodes) else ""
-        trace_name = tracetype_node.name_property
-        trace_datatype_class = tracetype_node.name_datatype_class
-        buffer.write(
-            f"""
-            '{trace_name}': '{trace_datatype_class}'{sfx}"""
-        )
-
-    buffer.write(
-        """
-        }"""
+    class_strs_map = dict(
+        [(node.name_property, node.name_datatype_class) for node in tracetype_nodes]
     )
 
-    class_map_repr = buffer.getvalue()
-
-    # Build params dict
-    # -----------------
-    params = {
-        "class_strs_map": class_map_repr,
-        "plotly_name": repr("data"),
-        "parent_name": repr(""),
+    return {
+        "class_strs_map": class_strs_map,
+        "plotly_name": "data",
+        "parent_name": "",
     }
 
-    return params
-
-
-def build_data_validator_py(base_trace_node: TraceNode):
-    """
-    Build source code for the DataValidator
-    (this is the validator that inputs a list of traces)
-
-    Parameters
-    ----------
-    base_trace_node : PlotlyNode
-        PlotlyNode that is the parent of all of the individual trace nodes
-    Returns
-    -------
-    str
-        Source code string for DataValidator class
-    """
-
-    # Get constructor params
-    # ----------------------
-    params = build_data_validator_params(base_trace_node)
-
-    # Build source code
-    # -----------------
-    buffer = StringIO()
-
-    buffer.write(
-        f"""
-import _plotly_utils.basevalidators
-
-class DataValidator(_plotly_utils.basevalidators.BaseDataValidator):
-
-    def __init__(self, plotly_name={params['plotly_name']},
-                       parent_name={params['parent_name']},
-                       **kwargs):
-
-        super().__init__({params['class_strs_map']}, plotly_name, parent_name, **kwargs)"""
-    )
-
-    return buffer.getvalue()
-
 
 def get_data_validator_instance(base_trace_node: TraceNode):
     """
@@ -223,42 +134,7 @@ def get_data_validator_instance(base_trace_node: TraceNode):
     # We need to eval the values to convert out of the repr-form of the
     # params. e.g. '3' -> 3
     params = build_data_validator_params(base_trace_node)
-    eval_params = {k: eval(repr_val) for k, repr_val in params.items()}
 
     # Build and return BaseDataValidator instance
     # -------------------------------------------
-    return _plotly_utils.basevalidators.BaseDataValidator(**eval_params)
-
-
-def write_data_validator_py(outdir, base_trace_node: TraceNode):
-    """
-    Construct and write out the DataValidator
-    (this is the validator that inputs a list of traces)
-
-    Parameters
-    ----------
-    outdir : str
-        Root outdir in which the top-level validators package should reside
-    base_trace_node : PlotlyNode
-        PlotlyNode that is the parent of all of the individual trace nodes
-    Returns
-    -------
-    None
-    """
-    # Validate inputs
-    # ---------------
-    if base_trace_node.node_path:
-        raise ValueError(
-            "Expected root trace node.\n"
-            'Received node with path "%s"' % base_trace_node.path_str
-        )
-
-    # Build Source
-    # ------------
-    source = build_data_validator_py(base_trace_node)
-
-    # Write file
-    # ----------
-    # filepath = opath.join(outdir, "validators", "__init__.py")
-    filepath = opath.join(outdir, "validators", "_data.py")
-    write_source_py(source, filepath, leading_newlines=2)
+    return _plotly_utils.basevalidators.BaseDataValidator(**params)