trying to get imports to work

Author: gvwilson

bin/codegen/__init__.py

@@ -6,7 +6,6 @@
 from codegen.datatypes import build_datatype_py, write_datatype_py  # noqa: F401
 from codegen.compatibility import (
     write_deprecated_datatypes,
-    write_graph_objs_graph_objs,
     DEPRECATED_DATATYPES,
 )
 from codegen.figure import write_figure_classes
@@ -60,7 +59,7 @@ def preprocess_schema(plotly_schema):
 matching the structure of `figure.layout` and `traceTemplate` is a dict
 matching the structure of the trace with type `trace_type` (e.g. 'scatter').
 Alternatively, this may be specified as an instance of
-plotly.graph_objs.layout.Template.
+plotly.graph_objects.layout.Template.
 
 Trace templates are applied cyclically to
 traces of each type. Container arrays (eg `annotations`) have special
@@ -89,22 +88,22 @@ def make_paths(codedir):
     """Make various paths needed for code generation."""
 
     validators_dir = codedir / "validators"
-    graph_objs_dir = codedir / "graph_objs"
+    graph_objects_dir = codedir / "graph_objects"
     graph_objects_path = codedir / "graph_objects" / "__init__.py"
-    return validators_dir, graph_objs_dir, graph_objects_path
+    return validators_dir, graph_objects_dir, graph_objects_path
 
 
 def perform_codegen(codedir, noformat=False):
     """Generate code."""
 
     # Get paths
-    validators_dir, graph_objs_dir, graph_objects_path = make_paths(codedir)
+    validators_dir, graph_objects_dir, graph_objects_path = make_paths(codedir)
 
     # Delete prior codegen output
     if validators_dir.exists():
         shutil.rmtree(validators_dir)
-    if graph_objs_dir.exists():
-        shutil.rmtree(graph_objs_dir)
+    if graph_objects_dir.exists():
+        shutil.rmtree(graph_objects_dir)
 
     # Load plotly schema
     project_root = codedir.parent
@@ -186,10 +185,10 @@ def perform_codegen(codedir, noformat=False):
         write_datatype_py(codedir, node)
 
     # Deprecated
-    # These are deprecated legacy datatypes like graph_objs.Marker
+    # These are deprecated legacy datatypes like graph_objects.Marker
     write_deprecated_datatypes(codedir)
 
-    # Write figure class to graph_objs
+    # Write figure class to graph_objects
     data_validator = get_data_validator_instance(base_traces_node)
     layout_validator = layout_node.get_validator_instance()
     frame_validator = frame_node.get_validator_instance()
@@ -222,11 +221,6 @@ def perform_codegen(codedir, noformat=False):
                 f".{node.name_undercase}"
             )
 
-    # Write plotly/graph_objs/graph_objs.py
-    # This is for backward compatibility. It just imports everything from
-    # graph_objs/__init__.py
-    write_graph_objs_graph_objs(codedir)
-
     # Add Figure and FigureWidget
     root_datatype_imports = datatype_rel_class_imports[()]
     root_datatype_imports.append("._figure.Figure")
@@ -235,71 +229,34 @@ def perform_codegen(codedir, noformat=False):
     for dep_clas in DEPRECATED_DATATYPES:
         root_datatype_imports.append(f"._deprecations.{dep_clas}")
 
-    optional_figure_widget_import = """
-if sys.version_info < (3, 7) or TYPE_CHECKING:
-    try:
-        import ipywidgets as _ipywidgets
-        from packaging.version import Version as _Version
-        if _Version(_ipywidgets.__version__) >= _Version("7.0.0"):
-            from ..graph_objs._figurewidget import FigureWidget
-        else:
-            raise ImportError()
-    except Exception:
-        from ..missing_anywidget import FigureWidget
-else:
-    __all__.append("FigureWidget")
-    orig_getattr = __getattr__
-    def __getattr__(import_name):
-        if import_name == "FigureWidget":
-            try:
-                import ipywidgets
-                from packaging.version import Version
-                if Version(ipywidgets.__version__) >= Version("7.0.0"):
-                    from ..graph_objs._figurewidget import FigureWidget
-                    return FigureWidget
-                else:
-                    raise ImportError()
-            except Exception:
-                from ..missing_anywidget import FigureWidget
-                return FigureWidget
-            else:
-                raise ImportError()
-
-        return orig_getattr(import_name)
-"""
     # __all__
     for path_parts, class_names in alls.items():
         if path_parts and class_names:
-            filepath = codedir / "graph_objs"
+            filepath = codedir / "graph_objects"
             filepath = filepath.joinpath(*path_parts) / "__init__.py"
             with open(filepath, "at") as f:
                 f.write(f"\n__all__ = {class_names}")
 
     # Output datatype __init__.py files
-    graph_objs_pkg = codedir / "graph_objs"
+    graph_objects_pkg = codedir / "graph_objects"
     for path_parts in datatype_rel_class_imports:
         rel_classes = sorted(datatype_rel_class_imports[path_parts])
         rel_modules = sorted(datatype_rel_module_imports.get(path_parts, []))
-        if path_parts == ():
-            init_extra = optional_figure_widget_import
-        else:
-            init_extra = ""
-        write_init_py(graph_objs_pkg, path_parts, rel_modules, rel_classes, init_extra)
+        write_init_py(graph_objects_pkg, path_parts, rel_modules, rel_classes)
 
     # Output graph_objects.py alias
     graph_objects_rel_classes = [
-        "..graph_objs." + rel_path.split(".")[-1]
+        "..graph_objects." + rel_path.split(".")[-1]
         for rel_path in datatype_rel_class_imports[()]
     ]
     graph_objects_rel_modules = [
-        "..graph_objs." + rel_module.split(".")[-1]
+        "..graph_objects." + rel_module.split(".")[-1]
         for rel_module in datatype_rel_module_imports[()]
     ]
 
     graph_objects_init_source = build_from_imports_py(
         graph_objects_rel_modules,
         graph_objects_rel_classes,
-        init_extra=optional_figure_widget_import,
     )
     graph_objects_path = codedir / "graph_objects"
     graph_objects_path.mkdir(parents=True, exist_ok=True)

bin/codegen/compatibility.py

@@ -42,7 +42,7 @@
 
 def build_deprecated_datatypes_py():
     """
-    Build datatype (graph_objs) class source code string for deprecated
+    Build datatype (graph_objects) class source code string for deprecated
     datatypes
 
     Returns
@@ -57,7 +57,7 @@ def build_deprecated_datatypes_py():
     buffer.write(
         r"""
 warnings.filterwarnings("default",
-                        r"plotly\.graph_objs\.\w+ is deprecated",
+                        r"plotly\.graph_objects\.\w+ is deprecated",
                         DeprecationWarning)
 
 
@@ -100,15 +100,15 @@ def build_deprecation_message(class_name, base_type, new):
     new: list of str
         List of replacements that users should use instead.
         Replacements may be:
-            - A package string relative to plotly.graph_objs. In this case the
+            - A package string relative to plotly.graph_objects. In this case the
               replacement class is assumed to be named `class_name`.
               e.g. `new` == ['layout`] and `class_name` == 'XAxis` corresponds
-              to the 'plotly.graph_objs.layout.XAxis' class
+              to the 'plotly.graph_objects.layout.XAxis' class
             - String containing the package and class. The string is
               identified as containing a class name if the final name in the
               package string begins with an uppercase letter.
               e.g. `new` == ['Scatter'] corresponds to the
-              ['plotly.graph_objs.Scatter'] class.
+              ['plotly.graph_objects.Scatter'] class.
             - The literal string 'etc.'. This string is not interpreted as a
               package or class and is displayed to the user as-is to
               indicate that the list of replacement classes is not complete.
@@ -129,21 +129,21 @@ def build_deprecation_message(class_name, base_type, new):
             if not repl_is_class:
                 repl_parts.append(class_name)
 
-            # Add plotly.graph_objs prefix
-            full_class_str = ".".join(["plotly", "graph_objs"] + repl_parts)
+            # Add plotly.graph_objects prefix
+            full_class_str = ".".join(["plotly", "graph_objects"] + repl_parts)
             replacements.append(full_class_str)
 
     replacemens_str = "\n  - ".join(replacements)
 
     if base_type is list:
         return f"""\
-plotly.graph_objs.{class_name} is deprecated.
+plotly.graph_objects.{class_name} is deprecated.
 Please replace it with a list or tuple of instances of the following types
   - {replacemens_str}
 """
     else:
         return f"""\
-plotly.graph_objs.{class_name} is deprecated.
+plotly.graph_objects.{class_name} is deprecated.
 Please replace it with one of the following more specific types
   - {replacemens_str}
 """
@@ -157,42 +157,15 @@ def write_deprecated_datatypes(codedir):
     Parameters
     ----------
     codedir :
-        Root directory in which the graph_objs package should reside
+        Root directory in which the graph_objects package should reside
 
     Returns
     -------
     None
     """
     # Generate source code
     datatype_source = build_deprecated_datatypes_py()
-    filepath = codedir / "graph_objs" / "_deprecations.py"
+    filepath = codedir / "graph_objects" / "_deprecations.py"
 
     # Write file
     write_source_py(datatype_source, filepath)
-
-
-def write_graph_objs_graph_objs(codedir):
-    """
-    Write the plotly/graph_objs/graph_objs.py file
-
-    This module just imports everything from the plotly.graph_objs package.
-    We write it for backward compatibility with legacy imports like:
-
-    from plotly.graph_objs import graph_objs
-
-    Parameters
-    ----------
-    codedir : str
-        Root directory in which the graph_objs package should reside
-
-    Returns
-    -------
-    None
-    """
-    filepath = codedir / "graph_objs" / "graph_objs.py"
-    with open(filepath, "wt") as f:
-        f.write(
-            """\
-from plotly.graph_objs import *
-"""
-        )

bin/codegen/datatypes.py

@@ -53,7 +53,7 @@ def get_typing_type(plotly_type, array_ok=False):
 
 def build_datatype_py(node):
     """
-    Build datatype (graph_objs) class source code string for a datatype
+    Build datatype (graph_objects) class source code string for a datatype
     PlotlyNode
 
     Parameters
@@ -73,14 +73,14 @@ def build_datatype_py(node):
     # Handle template traces
     #
     # We want template trace/layout classes like
-    # plotly.graph_objs.layout.template.data.Scatter to map to the
-    # corresponding trace/layout class (e.g. plotly.graph_objs.Scatter).
+    # plotly.graph_objects.layout.template.data.Scatter to map to the
+    # corresponding trace/layout class (e.g. plotly.graph_objects.Scatter).
     # So rather than generate a class definition, we just import the
     # corresponding trace/layout class
     if node.parent_path_str == "layout.template.data":
-        return f"from plotly.graph_objs import {node.name_datatype_class}"
+        return f"from plotly.graph_objects import {node.name_datatype_class}"
     elif node.path_str == "layout.template.layout":
-        return "from plotly.graph_objs import Layout"
+        return "from plotly.graph_objects import Layout"
 
     # Extract node properties
     datatype_class = node.name_datatype_class
@@ -175,13 +175,13 @@ def _subplot_re_match(self, prop):
     for subtype_node in subtype_nodes:
         if subtype_node.is_array_element:
             prop_type = (
-                f"tuple[plotly.graph_objs{node.dotpath_str}."
+                f"tuple[plotly.graph_objects{node.dotpath_str}."
                 + f"{subtype_node.name_datatype_class}]"
             )
 
         elif subtype_node.is_compound:
             prop_type = (
-                f"plotly.graph_objs{node.dotpath_str}."
+                f"plotly.graph_objects{node.dotpath_str}."
                 + f"{subtype_node.name_datatype_class}"
             )
 
@@ -291,7 +291,7 @@ def __init__(self"""
     # Constructor Docstring
     header = f"Construct a new {datatype_class} object"
     class_name = (
-        f"plotly.graph_objs{node.parent_dotpath_str}.{node.name_datatype_class}"
+        f"plotly.graph_objects{node.parent_dotpath_str}.{node.name_datatype_class}"
     )
 
     extras = [
@@ -582,12 +582,12 @@ def add_docstring(
 
 def write_datatype_py(outdir, node):
     """
-    Build datatype (graph_objs) class source code and write to a file
+    Build datatype (graph_objects) class source code and write to a file
 
     Parameters
     ----------
     outdir :
-        Root outdir in which the graph_objs package should reside
+        Root outdir in which the graph_objects package should reside
     node :
         The datatype node (node.is_datatype must evaluate to true) for which
         to build the datatype class
@@ -597,6 +597,6 @@ def write_datatype_py(outdir, node):
     None
     """
 
-    filepath = (outdir / "graph_objs").joinpath(*node.parent_path_parts) / f"_{node.name_undercase}.py"
+    filepath = (outdir / "graph_objects").joinpath(*node.parent_path_parts) / f"_{node.name_undercase}.py"
     datatype_source = build_datatype_py(node)
     write_source_py(datatype_source, filepath, leading_newlines=2)

bin/codegen/figure.py

@@ -255,7 +255,7 @@ def add_{trace_node.plotly_name}(self"""
         # Function body
         buffer.write(
             f"""
-        from plotly.graph_objs import {trace_node.name_datatype_class}
+        from plotly.graph_objects import {trace_node.name_datatype_class}
         new_trace = {trace_node.name_datatype_class}(
         """
         )
@@ -671,7 +671,7 @@ def add_{method_prefix}{singular_name}(self"""
         # Function body
         buffer.write(
             f"""
-        from plotly.graph_objs import layout as _layout
+        from plotly.graph_objects import layout as _layout
         new_obj = _layout.{node.name_datatype_class}(arg,
             """
         )
@@ -714,13 +714,13 @@ def write_figure_classes(
 ):
     """
     Construct source code for the Figure and FigureWidget classes and
-    write to graph_objs/_figure.py and graph_objs/_figurewidget.py
+    write to graph_objects/_figure.py and graph_objects/_figurewidget.py
     respectively
 
     Parameters
     ----------
     codedir : str
-        Root directory in which the graph_objs package should reside
+        Root directory in which the graph_objects package should reside
     trace_node : PlotlyNode
         Root trace node (the node that is the parent of all of the
         individual trace nodes like bar, scatter, etc.)
@@ -767,5 +767,5 @@ def write_figure_classes(
         )
 
         # Format and write to file
-        filepath = codedir / "graph_objs" / f"_{fig_classname.lower()}.py"
+        filepath = codedir / "graph_objects" / f"_{fig_classname.lower()}.py"
         write_source_py(figure_source, filepath)