pfund-plot 0.0.1__py3-none-any.whl

pfund_plot/typing.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, TypeAlias
+
+# NOTE: these are kept under TYPE_CHECKING because the backend libs (plotly, altair,
+# matplotlib, marimo, ...) are OPTIONAL dependencies. Importing them at runtime would
+# make `import pfund_plot.typing` crash for users who didn't install that extra.
+# Guarding here (+ `from __future__ import annotations` in consumers) keeps the names
+# available to type-checkers/IDEs while never importing the optional libs at runtime.
+if TYPE_CHECKING:
+    from altair import Chart as AltairChart
+    from anywidget import AnyWidget
+    from bokeh.plotting._figure import figure as BokehFigure
+    from holoviews.core.overlay import Overlay
+    from marimo import Html as MarimoHtml
+    from matplotlib.figure import Figure as MatplotlibFigure
+    from panel.io.threads import StoppableThread
+    from panel.layout import Panel
+    from panel.widgets import Widget
+    from plotly.graph_objects import Figure as PlotlyFigure
+
+    RawFigure = BokehFigure | PlotlyFigure | AltairChart | MatplotlibFigure
+    Figure = RawFigure | AnyWidget
+    Plot = Overlay | AnyWidget
+    Component = Panel | Widget | MarimoHtml
+    RenderedResult = Component | StoppableThread
+
+    Style: TypeAlias = dict[str, Any]
+    Control: TypeAlias = dict[str, Any]

pfund_plot/utils/__init__.py

@@ -0,0 +1,176 @@
+# pyright: reportUnknownMemberType=false, reportUnusedImport=false, reportMissingImports=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    import pandas as pd
+    from altair import Chart as AltairChart
+    from bokeh.model import Model as BokehModel
+    from holoviews.core import Dimensioned as HoloviewsDimensioned
+    from matplotlib.figure import Figure as MatplotlibFigure
+    from narwhals.typing import IntoFrame
+    from plotly.graph_objects import Figure as PlotlyFigure
+
+    from pfund_plot.plots.lazy import LazyPlot
+
+import datetime
+from pathlib import Path
+
+import narwhals as nw
+from pfeed.enums import DataTool
+
+
+def load_js(path: str) -> str:
+    js_code = Path(path).read_text()
+    return f"<script>{js_code}</script>"
+
+
+def convert_to_datetime(
+    date: str | datetime.datetime | pd.Timestamp,
+) -> datetime.datetime:
+    """Convert various date types to a naive UTC datetime.
+
+    Always returns tz-naive datetime (in UTC) because Panel/Bokeh widgets
+    don't handle tz-aware datetimes consistently in their internal validation.
+    """
+    if isinstance(date, str):
+        dt = datetime.datetime.fromisoformat(date)
+    elif isinstance(date, datetime.datetime):
+        dt = date
+    elif isinstance(date, datetime.date):
+        dt = datetime.datetime(date.year, date.month, date.day)
+    elif isinstance(date, pd.Timestamp):
+        dt = date.to_pydatetime()
+    else:
+        raise ValueError(f"Invalid date type: {type(date)}")
+    # convert to UTC then strip tzinfo — Panel widgets don't handle tz-aware datetimes consistently
+    if dt.tzinfo is not None:
+        dt = dt.astimezone(datetime.UTC).replace(tzinfo=None)
+    return dt
+
+
+def is_daily_data(df: nw.DataFrame[Any]) -> bool:
+    """Checks if the 'resolution' column is '1d' and the "ts" column by comparing the first two rows to see if the data is daily data."""
+    if df.is_empty():
+        return False
+    if "resolution" in df.columns and df.select("resolution").row(0)[0] == "1d":
+        return True
+    assert "date" in df.columns, "DataFrame must have a 'date' column"
+    assert isinstance(df.select("date").row(0)[0], datetime.datetime), (
+        '"date" column must be of type datetime'
+    )
+    date1 = df.select("date").row(0)[0]
+    if df.shape[0] >= 2:
+        date2 = df.select("date").row(1)[0]
+        delta = date2 - date1
+        return delta == datetime.timedelta(days=1)
+    return False
+
+
+def load_panel_extensions(extensions: list[str] | None = None):
+    import panel as pn
+
+    extensions = extensions or []
+    for extension in extensions:
+        if extension not in pn.extension._loaded_extensions:
+            pn.extension(extension)
+            print(f"loaded Panel extension: {extension}")
+
+
+def match_df_with_data_tool(df: IntoFrame) -> DataTool:
+    import pandas as pd
+
+    try:
+        import polars as pl
+    except ImportError:
+        pl = None
+    try:
+        import dask.dataframe as dd
+    except ImportError:
+        dd = None
+
+    if isinstance(df, pd.DataFrame):
+        return DataTool.pandas
+    elif pl and isinstance(df, (pl.DataFrame, pl.LazyFrame)):
+        return DataTool.polars
+    elif dd and isinstance(df, dd.DataFrame):
+        return DataTool.dask
+    else:
+        raise ValueError(
+            f"Unsupported dataframe type: {type(df)!r}. "
+            + "Expected a pandas.DataFrame, polars.DataFrame/LazyFrame, or dask.dataframe.DataFrame."
+        )
+
+
+def import_hvplot_df_module(data_tool: DataTool | str) -> None:
+
+    data_tool = DataTool[data_tool.lower()]
+    if data_tool == DataTool.pandas:
+        import hvplot.pandas
+    elif data_tool == DataTool.polars:
+        import hvplot.polars
+    elif data_tool == DataTool.dask:
+        import hvplot.dask  # noqa: F401
+    else:
+        raise ValueError(
+            f"Unsupported data tool: {data_tool}, must be one of ['pandas', 'polars', 'dask']"
+        )
+
+
+def convert_to_lazy_plot(
+    obj: PlotlyFigure
+    | AltairChart
+    | MatplotlibFigure
+    | BokehModel
+    | HoloviewsDimensioned,
+) -> LazyPlot:
+    """Convert plotting library figures to LazyPlot instances."""
+    import pfund_plot as plt
+
+    # Plotly
+    try:
+        import plotly.graph_objects as go
+
+        if isinstance(obj, go.Figure):
+            return plt.plotly(obj)
+    except ImportError:
+        pass
+
+    # Altair (TopLevelMixin is the common base for Chart, LayerChart, HConcatChart, VConcatChart, ConcatChart, FacetChart, RepeatChart)
+    try:
+        from altair import TopLevelMixin
+
+        if isinstance(obj, TopLevelMixin):
+            return plt.altair(obj)
+    except ImportError:
+        pass
+
+    # Matplotlib
+    try:
+        from matplotlib.figure import Figure as MatplotlibFigure
+
+        if isinstance(obj, MatplotlibFigure):
+            return plt.matplotlib(obj)
+    except ImportError:
+        pass
+
+    # Bokeh
+    try:
+        from bokeh.model import Model as BokehModel
+
+        if isinstance(obj, BokehModel):
+            return plt.bokeh(obj)
+    except ImportError:
+        pass
+
+    # Holoviews
+    try:
+        from holoviews.core import Dimensioned
+
+        if isinstance(obj, Dimensioned):
+            return plt.holoviews(obj)
+    except ImportError:
+        pass
+
+    return obj

pfund_plot/utils/bokeh.py

@@ -0,0 +1,177 @@
+# pyright: reportArgumentType=false, reportUnknownMemberType=false, reportUnknownVariableType=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    import narwhals as nw
+    from bokeh.models import CustomJSHover, HoverTool
+
+DatetimePrecision = Literal["d", "s", "ms"]
+
+DATETIME_PRECISION_FORMATS: dict[DatetimePrecision, str] = {
+    "d": "%Y-%m-%d",
+    "s": "%Y-%m-%d %H:%M:%S",
+    "ms": "%Y-%m-%d %H:%M:%S.%3N",
+}
+
+
+def get_datetime_hover_format(datetime_precision: DatetimePrecision) -> str:
+    if datetime_precision not in DATETIME_PRECISION_FORMATS:
+        raise ValueError(
+            f"Unsupported datetime_precision: {datetime_precision!r}, must be one of {list(DATETIME_PRECISION_FORMATS)}"
+        )
+    return DATETIME_PRECISION_FORMATS[datetime_precision]
+
+
+def create_number_formatter_for_hover_tool(
+    significant_digits: int = 6,
+) -> CustomJSHover:
+    """Create a number formatter for bokeh hover tools.
+    Args:
+        significant_digits: Number of significant digits to display
+    """
+    from bokeh.models import CustomJSHover
+
+    return CustomJSHover(
+        code=f"""
+        return value.toPrecision({significant_digits}).replace(/0+$/, '').replace(/\\.$/, '');
+    """
+    )
+
+
+def create_hover_col_format(
+    df: nw.DataFrame[Any],
+    col: str,
+    datetime_precision: DatetimePrecision = "s",
+) -> tuple[tuple[str, str], tuple[str, str | CustomJSHover] | None]:
+    """Create the tooltip and formatter for a single column based on its dtype.
+
+    Returns:
+        (tooltip, formatter_entry or None)
+        - tooltip: e.g. ("date", "@{date}{%Y-%m-%d %H:%M:%S}")
+        - formatter_entry: e.g. ("@{date}", "datetime"), or None if no formatter needed
+    """
+    num_formatter = create_number_formatter_for_hover_tool()
+    schema = df.collect_schema()
+    col_dtype = schema[col]
+    is_datetime = (
+        "datetime" in str(col_dtype).lower() or "date" in str(col_dtype).lower()
+    )
+    if is_datetime:
+        date_format = get_datetime_hover_format(datetime_precision)
+        return (col, f"@{{{col}}}{{{date_format}}}"), (f"@{{{col}}}", "datetime")
+    elif col_dtype.is_numeric():
+        return (col, f"@{{{col}}}{{custom}}"), (f"@{{{col}}}", num_formatter)
+    else:
+        return (col, f"@{{{col}}}"), None
+
+
+def _bundle_hover_config(
+    df: nw.DataFrame[Any],
+    x_col: str | None,
+    y_cols: list[str],
+    datetime_precision: DatetimePrecision = "s",
+) -> tuple[list[tuple[str, str]], dict[str, str | CustomJSHover]]:
+    """Build a single tooltip that bundles x + all y_cols together.
+
+    Only works when a single renderer's ColumnDataSource contains all the columns
+    (e.g. single-y plots, or the scatter workaround). For multi-y overlays where
+    hvplot creates separate renderers per y column, use create_hover_col_format()
+    to build per-column tooltips instead.
+    """
+    tooltips: list[tuple[str, str]] = []
+    formatters: dict[str, str | CustomJSHover] = {}
+    cols = ([x_col] if x_col is not None else []) + y_cols
+    for col in cols:
+        tooltip, formatter_entry = create_hover_col_format(df, col, datetime_precision)
+        tooltips.append(tooltip)
+        if formatter_entry is not None:
+            formatters[formatter_entry[0]] = formatter_entry[1]
+    return tooltips, formatters
+
+
+def create_bundled_hover_tool(
+    df: nw.DataFrame[Any],
+    x_col: str | None,
+    y_cols: list[str],
+    datetime_precision: DatetimePrecision = "s",
+) -> HoverTool:
+    """Create a HoverTool that shows all specified columns in one tooltip.
+
+    Only use when a single renderer's ColumnDataSource contains all the columns
+    (e.g. single-y plots, or the scatter workaround where one Scatter holds the
+    full dataframe). For multi-y overlays with separate renderers per y column
+    """
+    from bokeh.models import HoverTool
+
+    tooltips, formatters = _bundle_hover_config(df, x_col, y_cols, datetime_precision)
+    return HoverTool(tooltips=tooltips, formatters=formatters, mode="vline")
+
+
+def create_hover_scatter(
+    df: nw.DataFrame[Any],
+    x_col: str | None,
+    y_cols: list[str],
+    datetime_precision: DatetimePrecision = "s",
+    marker: str | None = None,
+) -> Any:
+    """Workaround: create a scatter overlay that provides hover tooltips.
+
+    Some hvplot chart types (e.g. area) render as Bokeh glyphs that transform
+    the data (e.g. Patch polygons), destroying the original column values in
+    the ColumnDataSource.
+
+    This works by overlaying scatter points whose ColumnDataSource contains the
+    original, untransformed data, so a HoverTool attached to it can reference
+    the real column values.
+
+    Args:
+        marker: marker shape string (e.g. 'circle', 'cross'). If None, points
+            are invisible (alpha=0) but still large enough for Bokeh's hit-testing.
+    """
+    import holoviews as hv
+
+    native_df = df.to_native()
+    hover_tool = create_bundled_hover_tool(df, x_col, y_cols, datetime_precision)
+    scatter_opts: dict[str, Any] = dict(
+        size=7 if marker else 15,
+        alpha=1 if marker else 0,
+        marker=marker or "circle",
+        tools=[hover_tool],
+        hover_mode="vline",
+    )
+    kdims = [x_col or "index"]
+
+    if len(y_cols) == 1:
+        return hv.Scatter(native_df, kdims=kdims, vdims=[y_cols[0]]).opts(
+            **scatter_opts
+        )
+    else:
+        scatters = {
+            y_col: hv.Scatter(native_df, kdims=kdims, vdims=[y_col]).opts(
+                **scatter_opts
+            )
+            for y_col in y_cols
+        }
+        return hv.NdOverlay(scatters)
+
+
+def create_vline_hover_opts(
+    df: nw.DataFrame[Any],
+    x_col: str | None,
+    y_cols: list[str],
+    datetime_precision: DatetimePrecision = "s",
+) -> Any:
+    """This shows the tooltip without needing the cursor to hover over the data points
+    Useful in plots like plt.line() for multi-line plots where the tooltips are separated for each line
+    """
+    from holoviews import opts
+
+    tooltips, formatters = _bundle_hover_config(df, x_col, y_cols, datetime_precision)
+    return opts.Curve(
+        tools=["hover"],
+        hover_mode="vline",
+        hover_tooltips=[("series", "@{Variable}"), *tooltips],
+        hover_formatters=formatters,
+    )

pfund_plot/widgets/base.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    import narwhals as nw
+    import panel as pn
+
+    from pfund_plot.plots.plot import MessageKey, StreamingDfs
+
+
+class BaseWidget(ABC):
+    # Columns this widget requires in the df (e.g. ["date"]).
+    REQUIRED_COLS: ClassVar[list[str] | None] = None
+
+    def __init__(
+        self,
+        df: nw.DataFrame[Any],
+        control: dict[str, Any],
+        update_callback: Callable[[nw.DataFrame[Any]], None],
+    ):
+        self._df = df
+        self._control: dict[str, Any] = control
+        self._update_callback = update_callback
+        self._overlays: list[BaseWidget] = []
+
+    @abstractmethod
+    def update_df(self, df: nw.DataFrame[Any]) -> None: ...
+
+    @abstractmethod
+    def get_panel_objects(self) -> list[pn.widgets.Widget]:
+        """Return the Panel widget objects to be placed in the toolbox."""
+        ...
+
+    def can_merge_with(self, other: BaseWidget) -> bool:
+        """Can this widget merge with another widget of the same class?
+        Same class = same REQUIRED_COLS = always compatible.
+        """
+        return True
+
+    def add_overlay(self, other: BaseWidget) -> None:
+        """Register an overlay widget so this widget's actions also update the overlay."""
+        self._overlays.append(other)
+
+
+class BaseStreamingWidget(ABC):
+    def __init__(
+        self,
+        streaming_dfs: StreamingDfs,
+        active_key: MessageKey,
+        update_callback: Callable[[MessageKey], None],
+    ):
+        self._streaming_dfs = streaming_dfs
+        self._active_key = active_key
+        self._update_callback = update_callback
+        self._overlays: list[BaseStreamingWidget] = []
+
+    @abstractmethod
+    def update_streaming_state(self, streaming_dfs: StreamingDfs) -> None: ...
+
+    @abstractmethod
+    def get_panel_objects(self) -> list[pn.widgets.Widget]:
+        """Return the Panel widget objects to be placed in the toolbox."""
+        ...
+
+    def can_merge_with(self, other: BaseStreamingWidget) -> bool:
+        """Can this widget merge with another streaming widget of the same class?
+        Merge if they operate on the same set of msg_keys (i.e. same feed).
+        """
+        return set(self._streaming_dfs.keys()) == set(other._streaming_dfs.keys())
+
+    def add_overlay(self, other: BaseStreamingWidget) -> None:
+        """Register an overlay streaming widget so this widget's actions also update the overlay."""
+        self._overlays.append(other)

pfund_plot/widgets/datetime_widget.py

@@ -0,0 +1,221 @@
+# pyright: reportUnknownMemberType=false, reportGeneralTypeIssues=false, reportUnusedParameter=false, reportUnknownVariableType=false, reportArgumentType=false, reportUnknownArgumentType=false, reportAttributeAccessIssue=false
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from narwhals.typing import Frame
+    from param.parameterized import Event
+
+import datetime
+
+import narwhals as nw
+import panel as pn
+
+from pfund_plot.utils import convert_to_datetime
+from pfund_plot.widgets.base import BaseWidget
+
+
+def round_date(dt: datetime.datetime, to: str = "floor") -> datetime.datetime:
+    """Round a datetime to the nearest second boundary.
+
+    When a user drags the DatetimeRangeSlider, Bokeh snaps BOTH slider handles
+    to the nearest step boundary (e.g. every 5000ms). This snapping truncates
+    sub-second precision, producing a value like 04:55:19.000 even if the original
+    datetime was 04:55:19.732. When that snapped value is synced back to the
+    DatetimeRangeInput, Panel validates it against the input's start/end bounds.
+    If the bound still has the original sub-second precision (04:55:19.732),
+    the snapped value (04:55:19.000) falls outside the bound and validation fails.
+
+    To prevent this, we round the bounds: floor the start date and ceil the end date,
+    so the bounds are always wider than any value the slider step quantization can produce.
+
+    Args:
+        dt: the datetime to round
+        to: 'floor' to round down (strip microseconds), 'ceil' to round up (next whole second)
+    """
+    if to == "floor":
+        return dt.replace(microsecond=0)
+    elif to == "ceil":
+        return dt.replace(microsecond=0) + datetime.timedelta(seconds=1)
+    else:
+        raise ValueError(f"Invalid rounding direction: {to}, must be 'floor' or 'ceil'")
+
+
+class DatetimeRangeWidget(BaseWidget):
+    REQUIRED_COLS: ClassVar[list[str] | None] = ["date"]
+
+    def __init__(
+        self,
+        df: nw.DataFrame[Any],
+        control: dict[str, Any],
+        update_callback: Callable[[nw.DataFrame[Any]], None],
+    ):
+        super().__init__(df, control, update_callback)
+        date_col = self._df["date"]
+        num_data_shown = date_col.len()
+        if "num_data" in control and control["num_data"] is not None:
+            num_data_shown = min(control["num_data"], num_data_shown)
+        start_date, end_date = (
+            convert_to_datetime(date_col[0]),
+            convert_to_datetime(date_col[-1]),
+        )
+        start_date = round_date(start_date, to="floor")
+        end_date = round_date(end_date, to="ceil")
+        data_shown_start_date = round_date(
+            convert_to_datetime(date_col[-num_data_shown]), to="floor"
+        )
+        self._datetime_range_input = pn.widgets.DatetimeRangeInput(
+            name="Datetime Range Input",
+            start=start_date,
+            end=end_date,
+            value=(data_shown_start_date, end_date),
+            width=150,
+        )
+        self._input_watcher = self._datetime_range_input.param.watch(
+            self._update_datetime_range_input, "value"
+        )
+        self._datetime_range_slider = pn.widgets.DatetimeRangeSlider(
+            name="Period",
+            start=start_date,
+            end=end_date,
+            value=(data_shown_start_date, end_date),
+            step=control["slider_step"] or self._derive_slider_step(),
+        )
+        self._slider_watcher = self._datetime_range_slider.param.watch(
+            self._update_datetime_range_slider, "value"
+        )
+        # self._max_data = pn.rx(df.shape[0])
+        # self._data_slider = pn.widgets.IntSlider(
+        #     name='Number of Most Recent Data Points',
+        #     value=num_data_shown,
+        #     start=control['num_data'],
+        #     end=self._max_data,
+        #     step=control['slider_step']
+        # )
+        # self._data_slider.param.watch(self._update_data_slider, 'value')
+        # self._show_all_button = pn.widgets.Button(name='Show All', button_type='primary')
+        # self._show_all_button.on_click(self._max_out_data_slider)
+
+    @property
+    def datetime_range_input(self) -> pn.widgets.DatetimeRangeInput:
+        return self._datetime_range_input
+
+    @property
+    def datetime_range_slider(self) -> pn.widgets.DatetimeRangeSlider:
+        return self._datetime_range_slider
+
+    def get_panel_objects(self) -> list[pn.widgets.Widget]:
+        return [self._datetime_range_input, self._datetime_range_slider]
+
+    @staticmethod
+    def _filter_df(
+        df: nw.DataFrame[Any],
+        start_date: datetime.datetime,
+        end_date: datetime.datetime,
+    ) -> Frame:
+        return df.filter((nw.col("date") >= start_date) & (nw.col("date") <= end_date))
+
+    def _fan_out_to_overlays(
+        self, start_date: datetime.datetime, end_date: datetime.datetime
+    ) -> None:
+        """Filter each overlay widget's full df by the same date range and trigger its update.
+        Must be called BEFORE the parent's _update_callback so the DynamicMap re-render
+        picks up the updated overlay dfs.
+        """
+        for overlay_widget in self._overlays:
+            filtered = self._filter_df(overlay_widget._df, start_date, end_date)
+            overlay_widget._update_callback(filtered)
+
+    def _derive_slider_step(self) -> int:
+        date_col = self._df["date"]
+        # infer resolution from data
+        resolution_ms = (date_col[1] - date_col[0]).total_seconds() * 1000
+        # use 5x resolution as step, so user can move meaningfully but not too coarsely
+        slider_step = int(resolution_ms * 5)
+        return slider_step
+
+    def _update_datetime_range_input(self, event: Event):
+        start_date, end_date = self._datetime_range_input.value
+        # silently update the _datetime_range_slider as well, temporarily remove the watcher
+        self._datetime_range_slider.param.unwatch(self._slider_watcher)
+        try:
+            _ = self._datetime_range_slider.param.update(value=(start_date, end_date))
+        finally:
+            self._slider_watcher = self._datetime_range_slider.param.watch(
+                self._update_datetime_range_slider, "value"
+            )
+        # update overlay dfs BEFORE parent re-render so DynamicMap picks them up
+        self._fan_out_to_overlays(start_date, end_date)
+        df_filtered = self._filter_df(self._df, start_date, end_date)
+        self._update_callback(df_filtered)
+
+    def _update_datetime_range_slider(self, event: Event):
+        start_date, end_date = self._datetime_range_slider.value
+        # silently update the _datetime_range_input as well, temporarily remove the watcher
+        self._datetime_range_input.param.unwatch(self._input_watcher)
+        try:
+            _ = self._datetime_range_input.param.update(value=(start_date, end_date))
+        finally:
+            self._input_watcher = self._datetime_range_input.param.watch(
+                self._update_datetime_range_input, "value"
+            )
+        # update overlay dfs BEFORE parent re-render so DynamicMap picks them up
+        self._fan_out_to_overlays(start_date, end_date)
+        df_filtered = self._filter_df(self._df, start_date, end_date)
+        self._update_callback(df_filtered)
+
+    def update_df(self, df: nw.DataFrame[Any]):
+        """Update widget bounds and df reference for new df (currently only used when receiving streaming data)."""
+        self._df = df
+        if self._df.shape[0] < 2:
+            raise ValueError("df must have at least 2 rows")
+        date_col = df["date"]
+        new_end = round_date(convert_to_datetime(date_col[-1]), to="ceil")
+
+        self._datetime_range_input.param.unwatch(self._input_watcher)
+        self._datetime_range_slider.param.unwatch(self._slider_watcher)
+        try:
+            # check if slider was at the end before updating
+            # NOTE: strip tzinfo before comparing because Panel/Bokeh may return
+            # tz-aware datetimes from .value after user interaction
+            slider_start, slider_end = self._datetime_range_slider.value
+
+            was_at_end = convert_to_datetime(slider_end) >= convert_to_datetime(
+                self._datetime_range_slider.end
+            )
+
+            # expand bounds
+            self._datetime_range_slider.end = new_end
+            self._datetime_range_input.end = new_end
+
+            # auto-extend value to include new data if slider was at the end
+            if was_at_end:
+                _ = self._datetime_range_slider.param.update(
+                    value=(slider_start, new_end)
+                )
+                _ = self._datetime_range_input.param.update(
+                    value=(slider_start, new_end)
+                )
+        finally:
+            self._input_watcher = self._datetime_range_input.param.watch(
+                self._update_datetime_range_input, "value"
+            )
+            self._slider_watcher = self._datetime_range_slider.param.watch(
+                self._update_datetime_range_slider, "value"
+            )
+
+    # @property
+    # def data_slider(self) -> pn.widgets.IntSlider:
+    #     return self._data_slider
+
+    # @property
+    # def show_all_button(self) -> pn.widgets.Button:
+    #     return self._show_all_button
+
+    # def _update_data_slider(self, event: Event):
+    #     self._update_callback(self._df.tail(self._data_slider.value))
+
+    # def _max_out_data_slider(self, event: Event):
+    #     self._data_slider.value = self._max_data.rx.value