swapping graph_objs and graph_objects

Author: gvwilson

_plotly_utils/basevalidators.py

@@ -2370,26 +2370,26 @@ def __init__(self, plotly_name, parent_name, data_class_str, data_docs, **kwargs
     @staticmethod
     def compute_graph_obj_module_str(data_class_str, parent_name):
         if parent_name == "frame" and data_class_str in ["Data", "Layout"]:
-            # Special case. There are no graph_objs.frame.Data or
-            # graph_objs.frame.Layout classes. These are remapped to
-            # graph_objs.Data and graph_objs.Layout
+            # Special case. There are no graph_objects.frame.Data or
+            # graph_objects.frame.Layout classes. These are remapped to
+            # graph_objects.Data and graph_objects.Layout
 
             parent_parts = parent_name.split(".")
-            module_str = ".".join(["plotly.graph_objs"] + parent_parts[1:])
+            module_str = ".".join(["plotly.graph_objects"] + parent_parts[1:])
         elif parent_name == "layout.template" and data_class_str == "Layout":
             # Remap template's layout to regular layout
-            module_str = "plotly.graph_objs"
+            module_str = "plotly.graph_objects"
         elif "layout.template.data" in parent_name:
             # Remap template's traces to regular traces
             parent_name = parent_name.replace("layout.template.data.", "")
             if parent_name:
-                module_str = "plotly.graph_objs." + parent_name
+                module_str = "plotly.graph_objects." + parent_name
             else:
-                module_str = "plotly.graph_objs"
+                module_str = "plotly.graph_objects"
         elif parent_name:
-            module_str = "plotly.graph_objs." + parent_name
+            module_str = "plotly.graph_objects." + parent_name
         else:
-            module_str = "plotly.graph_objs"
+            module_str = "plotly.graph_objects"
 
         return module_str
 
@@ -2580,7 +2580,7 @@ def description(self):
     def get_trace_class(self, trace_name):
         # Import trace classes
         if trace_name not in self._class_map:
-            trace_module = import_module("plotly.graph_objs")
+            trace_module = import_module("plotly.graph_objects")
             trace_class_name = self.class_strs_map[trace_name]
             self._class_map[trace_name] = getattr(trace_module, trace_class_name)
 
@@ -2591,7 +2591,7 @@ def validate_coerce(self, v, skip_invalid=False, _validate=True):
 
         # Import Histogram2dcontour, this is the deprecated name of the
         # Histogram2dContour trace.
-        from plotly.graph_objs import Histogram2dcontour
+        from plotly.graph_objects import Histogram2dcontour
 
         if v is None:
             v = []

bin/codegen/__init__.py

@@ -6,7 +6,7 @@
 from codegen.datatypes import build_datatype_py, write_datatype_py  # noqa: F401
 from codegen.compatibility import (
     write_deprecated_datatypes,
-    write_graph_objs_graph_objs,
+    write_graph_objects_graph_objects,
     DEPRECATED_DATATYPES,
 )
 from codegen.figure import write_figure_classes
@@ -60,7 +60,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 +89,22 @@ def make_paths(codedir):
     """Make various paths needed for code generation."""
 
     validators_dir = codedir / "validators"
-    graph_objs_dir = codedir / "graph_objs"
-    graph_objects_path = codedir / "graph_objects" / "__init__.py"
-    return validators_dir, graph_objs_dir, graph_objects_path
+    graph_objects_dir = codedir / "graph_objects"
+    graph_objs_path = codedir / "graph_objs" / "__init__.py"
+    return validators_dir, graph_objects_dir, graph_objs_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_objs_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 +186,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,10 +222,10 @@ def perform_codegen(codedir, noformat=False):
                 f".{node.name_undercase}"
             )
 
-    # Write plotly/graph_objs/graph_objs.py
+    # Write plotly/graph_objects/graph_objects.py
     # This is for backward compatibility. It just imports everything from
-    # graph_objs/__init__.py
-    write_graph_objs_graph_objs(codedir)
+    # graph_objects/__init__.py
+    write_graph_objects_graph_objects(codedir)
 
     # Add Figure and FigureWidget
     root_datatype_imports = datatype_rel_class_imports[()]
@@ -241,7 +241,7 @@ def perform_codegen(codedir, noformat=False):
         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
+            from ..graph_objects._figurewidget import FigureWidget
         else:
             raise ImportError()
     except Exception:
@@ -255,7 +255,7 @@ def __getattr__(import_name):
                 import ipywidgets
                 from packaging.version import Version
                 if Version(ipywidgets.__version__) >= Version("7.0.0"):
-                    from ..graph_objs._figurewidget import FigureWidget
+                    from ..graph_objects._figurewidget import FigureWidget
                     return FigureWidget
                 else:
                     raise ImportError()
@@ -270,43 +270,43 @@ def __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, init_extra)
 
-    # Output graph_objects.py alias
-    graph_objects_rel_classes = [
-        "..graph_objs." + rel_path.split(".")[-1]
+    # Output graph_objs.py alias
+    graph_objs_rel_classes = [
+        "..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_objs_rel_modules = [
+        "..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,
+    graph_objs_init_source = build_from_imports_py(
+        graph_objs_rel_modules,
+        graph_objs_rel_classes,
         init_extra=optional_figure_widget_import,
     )
-    graph_objects_path = codedir / "graph_objects"
-    graph_objects_path.mkdir(parents=True, exist_ok=True)
-    graph_objects_path /=  "__init__.py"
-    with open(graph_objects_path, "wt") as f:
+    graph_objs_path = codedir / "graph_objs"
+    graph_objs_path.mkdir(parents=True, exist_ok=True)
+    graph_objs_path /=  "__init__.py"
+    with open(graph_objs_path, "wt") as f:
         f.write("# ruff: noqa: F401\n")
-        f.write(graph_objects_init_source)
+        f.write(graph_objs_init_source)
 
 
 if __name__ == "__main__":

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,42 @@ 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):
+def write_graph_objects_graph_objects(codedir):
     """
-    Write the plotly/graph_objs/graph_objs.py file
+    Write the plotly/graph_objects/graph_objects.py file
 
-    This module just imports everything from the plotly.graph_objs package.
+    This module just imports everything from the plotly.graph_objects package.
     We write it for backward compatibility with legacy imports like:
 
-    from plotly.graph_objs import graph_objs
+    from plotly.graph_objects import graph_objects
 
     Parameters
     ----------
     codedir : str
-        Root directory in which the graph_objs package should reside
+        Root directory in which the graph_objects package should reside
 
     Returns
     -------
     None
     """
-    filepath = codedir / "graph_objs" / "graph_objs.py"
+    filepath = codedir / "graph_objects" / "graph_objects.py"
     with open(filepath, "wt") as f:
         f.write(
             """\
-from plotly.graph_objs import *
+from plotly.graph_objects 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)