Prototype demonstrating possible px.overlay

packages/python/plotly/plotly/basedatatypes.py

@@ -391,6 +391,9 @@ class is a subclass of both BaseFigure and widgets.DOMWidget.
         self._animation_duration_validator = animation.DurationValidator()
         self._animation_easing_validator = animation.EasingValidator()
 
+        # Space for auxiliary data
+        self._aux = dict()
+
         # Template
         # --------
         # ### Check for default template ###

packages/python/plotly/plotly/express/_core.py

@@ -2057,6 +2057,8 @@ def make_figure(args, constructor, trace_patch=None, layout_patch=None):
 
     configure_axes(args, constructor, fig, orders)
     configure_animation_controls(args, constructor, fig)
+    # store args in figure metadata
+    fig._aux["px"] = dict(args=args)
     return fig
 
 

proto/px_overlay/README.md

@@ -0,0 +1,15 @@
+# `px.overlay` prototype
+
+This demonstrates one possible way of combining two figures into a single
+figure.
+
+To see an example, run (from the root of the `plotly.py` repo):
+
+```bash
+PYTHONPATH=proto/px_overlay python proto/px_overlay/multilayered_data_test.py
+```
+
+To see the code that does the overlaying, start with the `px_simple_overlay`
+function in `proto/px_overlay/px_overlay.py`. In this function there are a few
+comments marked with `TODO` that indicate places for improvement in the
+functionality.

proto/px_overlay/facet_col_wrap_test.py

@@ -0,0 +1,27 @@
+import plotly.express as px
+import test_data
+from px_combine import px_simple_combine
+
+df = test_data.multilayered_data(d_divs=[6, 3, 2], rwalk=0.1)
+last_cat = df.columns[2]
+last_cat_types = list(set(df[last_cat]))
+fig0 = px.line(
+    df.loc[df[last_cat] == last_cat_types[0]],
+    x="x",
+    y="y",
+    facet_col=df.columns[0],
+    facet_col_wrap=3,
+    color=df.columns[1],
+).update_layout(title="%s=%s" % (last_cat, last_cat_types[0]))
+fig1 = px.line(
+    df.loc[df[last_cat] == last_cat_types[1]],
+    x="x",
+    y="y",
+    facet_col=df.columns[0],
+    facet_col_wrap=3,
+    color=df.columns[1],
+).update_layout(title="%s=%s" % (last_cat, last_cat_types[1]))
+fig = px_simple_combine(fig0, fig1, fig1_secondary_y=True)
+fig0.show()
+fig1.show()
+fig.show()

proto/px_overlay/find_field.py

@@ -0,0 +1,43 @@
+import plotly.graph_objects as go
+from plotly import basedatatypes
+
+# Search down an object's composition tree and find fields with a given name
+
+
+def find_field(obj, field, basepath="", max_path_len=80, forbidden=["parent"]):
+    if obj is not None and len(basepath) < max_path_len:
+        for f in dir(obj):
+            joined_path = ".".join([basepath, f])
+            if f == field:
+                print(joined_path)
+            if (
+                (f not in forbidden)
+                and (not f.startswith("_"))
+                and (not f.endswith("_"))
+            ):
+                find_field(eval("obj.%s" % (f,)), field, joined_path)
+
+
+def find_all_xy_traces():
+    for field in dir(go):
+        call_str = "go.%s" % (field,)
+        call = eval(call_str)
+        try:
+            if issubclass(call, basedatatypes.BaseTraceType):
+                obj = call()
+                if "xaxis" in obj and "yaxis" in obj:
+                    yield (call_str)
+        except TypeError:
+            pass
+
+
+# s=go.Scatter()
+# s=go.Bar()
+# find_field(s,"color",basepath="scatter")
+# print()
+# find_field(s,"color",basepath="bar")
+
+for call_str in find_all_xy_traces():
+    call = eval(call_str)
+    find_field(call(), "color", basepath=call_str)
+    print()

proto/px_overlay/map_axis_pair_example.py

@@ -0,0 +1,29 @@
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+import px_overlay
+import pytest
+
+fig0 = px_overlay.make_subplots_all_secondary_y(3, 4)
+fig1 = px_overlay.make_subplots_all_secondary_y(4, 5)
+
+for dims, f in zip([(3, 4), (4, 5)], [fig0, fig1]):
+    for r, c in px_overlay.multi_index(*dims):
+        for sy in [False, True]:
+            f.add_trace(go.Scatter(x=[], y=[]), row=r + 1, col=c + 1, secondary_y=sy)
+
+fig0.add_annotation(row=2, col=3, text="hi", x=0.25, xref="x domain", y=3)
+fig0.add_annotation(
+    row=3, col=4, text="hi", x=0.25, xref="x domain", y=2, secondary_y=True
+)
+
+for an in fig0.layout.annotations:
+    oldaxpair = tuple([an[ref] for ref in ["xref", "yref"]])
+    newaxpair = px_overlay.map_axis_pair(fig0, fig1, oldaxpair)
+    newan = go.layout.Annotation(an)
+    print(oldaxpair)
+    print(newaxpair)
+    newan["xref"], newan["yref"] = newaxpair
+    fig1.add_annotation(newan)
+
+fig0.show()
+fig1.show()

proto/px_overlay/multilayered_data_test.py

@@ -0,0 +1,56 @@
+import test_data
+import numpy as np
+import plotly.express as px
+from px_overlay import px_simple_overlay
+
+# Demonstrates px_overlay prototype.
+
+# Make some data that can be faceted by row, col and color, and split into 2
+# sets, which will go to the first and second figure respectively.
+df = test_data.multilayered_data(d_divs=[2, 3, 4, 2], rwalk=0.1)
+
+# The titles of the figures use the last dimension in the data. The title is
+# formatted "column_name=column_value", so here we extract the column name.
+last_cat = df.columns[3]
+figs = []
+for px_call, last_cat_0 in zip([px.line, px.bar], list(set(df[last_cat]))):
+    # px_call is the chart type to make and last_cat_0 is the column_value for
+    # that figure which is used in forming the title.
+    df_slice = df.loc[df[last_cat] == last_cat_0]
+    fig = px_call(
+        df_slice,
+        x="x",
+        y="y",
+        facet_row=df.columns[0],
+        facet_col=df.columns[1],
+        color=df.columns[2],
+    )
+
+    fig.update_layout(title="%s=%s" % (last_cat, last_cat_0,))
+    figs.append(fig)
+
+# Add some annotations to make sure they are copied to the final figure properly
+figs[0].add_hline(y=1, row=1, col="all")
+figs[0].add_annotation(
+    x=0.25, y=0.5, xref="x domain", yref="y domain", row=2, col=3, text="yo"
+)
+# Note that these annotations should be mapped to a secondary y axis (observe this
+# in the final figure by dragging their corresponding secondary y axes).
+figs[1].add_vline(x=10, row="all", col=2)
+figs[1].add_annotation(
+    x=0.5, y=0.35, xref="x domain", yref="y", row=1, col=2, text="budday"
+)
+# Set the bar modes for both to see that the first figure that the barmode for
+# the final figure will be taken from the figure that has bars.
+figs[0].layout.barmode = "group"
+figs[1].layout.barmode = "relative"
+
+# overlay the figures
+final_fig = px_simple_overlay(*figs, fig1_secondary_y=True)
+
+# Show the initial figures
+for fig in figs:
+    fig.show()
+
+# Show the final figure
+final_fig.show()