✨ register plotly-resampler

plotly_resampler/__init__.py

@@ -1,25 +1,32 @@
 """**plotly\_resampler**: visualizing large sequences."""
 
-from .aggregation import (
-    LTTB,
-    EfficientLTTB,
-    EveryNthPoint,
-    FuncAggregator,
-    MinMaxOverlapAggregator,
-)
+from .aggregation import LTTB, EfficientLTTB, EveryNthPoint
 from .figure_resampler import FigureResampler, FigureWidgetResampler
+from .registering import register_plotly_resampler, unregister_plotly_resampler
 
 __docformat__ = "numpy"
 __author__ = "Jonas Van Der Donckt, Jeroen Van Der Donckt, Emiel Deprost"
-__version__ = "0.6.4.2"
+__version__ = "0.7.0"
 
 __all__ = [
     "__version__",
     "FigureResampler",
     "FigureWidgetResampler",
     "EfficientLTTB",
-    "MinMaxOverlapAggregator",
     "LTTB",
     "EveryNthPoint",
     "FuncAggregator",
+    "register_plotly_resampler",
+    "unregister_plotly_resampler",
 ]
+
+
+try:  # Enable ipywidgets on google colab!
+    import sys
+
+    if "google.colab" in sys.modules:
+        from google.colab import output
+
+        output.enable_custom_widget_manager()
+except ImportError:
+    pass

plotly_resampler/figure_resampler/figure_resampler.py

@@ -17,18 +17,20 @@
 import plotly.graph_objects as go
 from dash import Dash
 from jupyter_dash import JupyterDash
+from plotly.basedatatypes import BaseFigure
 from trace_updater import TraceUpdater
 
-from .figure_resampler_interface import AbstractFigureAggregator
 from ..aggregation import AbstractSeriesAggregator, EfficientLTTB
+from .figure_resampler_interface import AbstractFigureAggregator
+from .utils import is_figure, is_fr
 
 
 class FigureResampler(AbstractFigureAggregator, go.Figure):
     """Data aggregation functionality for ``go.Figures``."""
 
     def __init__(
         self,
-        figure: go.Figure = None,
+        figure: BaseFigure | dict = None,
         convert_existing_traces: bool = True,
         default_n_shown_samples: int = 1000,
         default_downsampler: AbstractSeriesAggregator = EfficientLTTB(),
@@ -39,12 +41,27 @@ def __init__(
         show_mean_aggregation_size: bool = True,
         verbose: bool = False,
     ):
-        if figure is None:
-            figure = go.Figure()
+        # Parse the figure input before calling `super`
+        if is_figure(figure) and not is_fr(figure):  # go.Figure
+            # Base case, the figure does not need to be adjusted
+            f = figure
+        else:
+            # Create a new figure object and make sure that the trace uid will not get
+            # adjusted when they are added.
+            f = self._get_figure_class(go.Figure)()
+            f._data_validator.set_uid = False
+
+            if isinstance(figure, BaseFigure):  # go.FigureWidget or AbstractFigureAggregator
+                # A base figure object, we first copy the layout and grid ref
+                f.layout = figure.layout
+                f._grid_ref = figure._grid_ref
+                f.add_traces(figure.data)
+            elif isinstance(figure, (dict, list)):
+                # A single trace dict or a list of traces
+                f.add_traces(figure)
 
-        assert isinstance(figure, go.Figure)
         super().__init__(
-            figure,
+            f,
             convert_existing_traces,
             default_n_shown_samples,
             default_downsampler,
@@ -53,11 +70,34 @@ def __init__(
             verbose,
         )
 
+        if isinstance(figure, AbstractFigureAggregator):
+            # Copy the `_hf_data` if the previous figure was an AbstractFigureAggregator
+            # and adjust the default `max_n_samples` and `downsampler`
+            self._hf_data.update(
+                self._copy_hf_data(figure._hf_data, adjust_default_values=True)
+            )
+
+            # Note: This hack ensures that the this figure object initially uses
+            # data of the whole view. More concretely; we create a dict
+            # serialization figure and adjust the hf-traces to the whole view
+            # with the check-update method (by passing no range / filter args)
+            with self.batch_update():
+                graph_dict: dict = self._get_current_graph()
+                update_indices = self._check_update_figure_dict(graph_dict)
+                for idx in update_indices:
+                    self.data[idx].update(graph_dict["data"][idx])
+
         # The FigureResampler needs a dash app
         self._app: JupyterDash | Dash | None = None
         self._port: int | None = None
         self._host: str | None = None
 
+    # @staticmethod
+    # def _get_figure_class() -> type:
+    #     """Return the class of the underlying figure."""
+    #     from ..module import get_plotly_constr
+    #     return get_plotly_constr(go.Figure)
+
     def show_dash(
         self,
         mode=None,