pfund-plot 0.0.1__py3-none-any.whl

pfund_plot/mixins/streaming_market_feed_mixin.py

@@ -0,0 +1,162 @@
+# pyright: reportArgumentType=false, reportOptionalMemberAccess=false, reportOptionalSubscript=false, reportCallIssue=false, reportUnknownMemberType=false, reportUnknownVariableType=false, reportUnknownArgumentType=false, reportAttributeAccessIssue=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, cast
+
+if TYPE_CHECKING:
+    from pfeed.requests.market_feed_stream_request import MarketFeedStreamRequest
+    from pfeed.streaming import BarMessage, TickMessage
+    from pfeed.streaming.market_data_message import MarketDataMessage
+    from pfund.datas.resolution import Resolution
+
+    from pfund_plot.plots.plot import MessageKey
+
+import narwhals as nw
+from pfund_kit.style import RichColor, TextStyle, cprint
+
+
+class StreamingMarketFeedMixin:
+    def _is_streaming_ready(self) -> bool:
+        """Return True if all streaming dataframes have at least 2 rows (needed for e.g. ohlc to compute candle width)."""
+        if not self._streaming_dfs:
+            return False
+        return all(df.shape[0] >= 2 for df in self._streaming_dfs.values())
+
+    def _start_streaming(self):
+        from pfund_plot.utils import import_hvplot_df_module
+
+        # streaming always uses polars internally (see _create_streaming_row)
+        import_hvplot_df_module("polars")
+
+        requests = cast("list[MarketFeedStreamRequest]", self._feed._requests)
+        for request in requests:
+            resolution = cast("Resolution", request.target_resolution)
+            if resolution.is_bar():
+                if self._y is not None:
+                    assert self._y in ["open", "high", "low", "close", "volume"], (
+                        "y must be 'open', 'high', 'low', 'close', or 'volume' when streaming bar data"
+                    )
+            elif resolution.is_tick():
+                if self._y is not None:
+                    assert self._y in ["price", "volume"], (
+                        "y must be 'price' or 'volume' when streaming tick data"
+                    )
+            else:
+                raise ValueError(f"Unsupported resolution: {resolution}")
+
+        super()._start_streaming()
+
+    def _create_streaming_row(self, msg: MarketDataMessage) -> nw.DataFrame[Any]:
+        import polars as pl
+
+        if msg.is_tick():
+            tick_msg = cast("TickMessage", msg)
+            return nw.from_native(
+                pl.DataFrame(
+                    {
+                        # msg.ts is int64 ns since epoch; from_epoch yields a tz-naive
+                        # (already UTC) datetime[ns], preserving nanosecond precision
+                        "date": pl.from_epoch(pl.Series([tick_msg.ts]), time_unit="ns"),
+                        "price": [tick_msg.price],
+                        # volume can be None (e.g. yahoo finance); pin dtype so a leading
+                        # None row doesn't become a Null column and break later concats
+                        "volume": pl.Series([tick_msg.volume], dtype=pl.Float64),
+                    }
+                )
+            )
+        elif msg.is_bar():
+            bar_msg = cast("BarMessage", msg)
+            return nw.from_native(
+                pl.DataFrame(
+                    {
+                        # bar_msg.start_ts is int64 ns since epoch (start of bar);
+                        # from_epoch yields a tz-naive (already UTC) datetime[ns]
+                        "date": pl.from_epoch(
+                            pl.Series([bar_msg.start_ts]), time_unit="ns"
+                        ),
+                        "open": [bar_msg.open],
+                        "high": [bar_msg.high],
+                        "low": [bar_msg.low],
+                        "close": [bar_msg.close],
+                        "volume": [bar_msg.volume],
+                    }
+                )
+            )
+        else:
+            raise ValueError(f"Unsupported streaming message type: {type(msg)}")
+
+    def _create_streaming_df(
+        self, msg_key: MessageKey, msg: MarketDataMessage
+    ) -> nw.DataFrame[Any]:
+        new_row = self._create_streaming_row(msg)
+
+        if msg_key not in self._streaming_dfs:
+            import datetime
+
+            from pfund.datas.resolution import Resolution
+
+            # prepend a dummy row so df starts with 2 rows,
+            # needed for DatetimeRangeWidget to derive slider step from date_col[1] - date_col[0]
+            if msg.is_bar():
+                resolution_seconds = Resolution(msg.resolution).to_seconds()
+            else:
+                # for tick data, use 1 second as the dummy interval
+                resolution_seconds = 1
+            dummy = new_row.with_columns(
+                # cast back to ns: subtracting a timedelta downcasts datetime[ns] -> datetime[us],
+                # which would then fail to concat with the ns-precision new_row below
+                (nw.col("date") - datetime.timedelta(seconds=resolution_seconds)).cast(
+                    nw.Datetime("ns")
+                ),
+            )
+            cprint(
+                f"Prepending dummy row for {msg_key} to ensure at least 2 data points for the {self._class_name}\n"
+                + "i.e. The first data point is dummy data",
+                style=TextStyle.BOLD + RichColor.YELLOW,
+            )
+            df = nw.concat([dummy, new_row])
+        else:
+            # update the streaming dataframe
+            existing_df = self._streaming_dfs[msg_key]
+            last_date = existing_df["date"][-1]
+            new_date = new_row["date"][0]
+            if new_date == last_date:
+                # same bar — replace last row
+                if msg.is_bar():
+                    df = nw.concat([existing_df.head(-1), new_row])
+                # NOTE: tick data could have the same timestamp!
+                elif msg.is_tick():
+                    df = nw.concat([existing_df, new_row])
+                else:
+                    raise ValueError(f"Unsupported streaming message type: {type(msg)}")
+            elif new_date > last_date:
+                df = nw.concat([existing_df, new_row])
+            else:
+                raise ValueError(
+                    f"New date {new_date} is before last date {last_date}, something is wrong with the streaming data"
+                )
+        return df
+
+    def _create_msg_key(self, msg: MarketDataMessage) -> MessageKey:
+        """Create a message key for streaming"""
+        msg_key = (msg.product, msg.resolution)
+        # set the first product as active by default
+        if self._active_msg_key is None:
+            self._active_msg_key = msg_key
+        return msg_key
+
+    # NOTE: this is added to streaming feed as a custom transformation
+    def _on_streaming_callback(self, msg: MarketDataMessage) -> MarketDataMessage:
+        # for bar data, skip incremental updates unless incremental_update is enabled
+        if (
+            msg.is_bar()
+            and not self._control["incremental_update"]
+            and msg.is_incremental
+        ):  # pyright: ignore[reportAttributeAccessIssue]
+            return msg
+
+        msg_key = self._create_msg_key(msg)
+        df = self._create_streaming_df(msg_key, msg)
+        self._update_streaming_df(msg_key, df)
+
+        return msg

pfund_plot/plots/altair.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Literal
+
+if TYPE_CHECKING:
+    from altair import Chart as AltairChart
+
+from pfund_plot.enums import PlottingBackend
+from pfund_plot.plots.plot import BasePlot
+
+
+class Altair(BasePlot):
+    SUPPORTED_BACKENDS: ClassVar[list[Literal[PlottingBackend.altair]]] = [
+        PlottingBackend.altair
+    ]
+    REQUIRED_DATA: ClassVar[bool] = False
+
+    def __init__(
+        self, fig: AltairChart, sizing_mode: str | None = None, **pane_kwargs: Any
+    ):
+        """
+        Args:
+            fig: An Altair Chart object.
+            sizing_mode: Panel sizing mode: e.g. "stretch_width", "stretch_height", or "stretch_both".
+            **pane_kwargs: Additional keyword arguments passed to pn.pane.Vega,
+                e.g. height, width, max_width, margin.
+        """
+        super().__init__(data=None)
+        self._plot: AltairChart = fig
+        self._pane_kwargs = pane_kwargs
+        if sizing_mode is not None:
+            self._pane_kwargs["sizing_mode"] = sizing_mode

pfund_plot/plots/area/__init__.py

@@ -0,0 +1,82 @@
+# pyright: reportArgumentType=false, reportOptionalMemberAccess=false, reportOptionalSubscript=false, reportCallIssue=false, reportUnknownMemberType=false, reportUnknownVariableType=false, reportUnknownArgumentType=false
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from narwhals.typing import IntoFrame
+    from pfeed.feeds.market_feed import MarketFeed
+
+    from pfund_plot.widgets.base import BaseStreamingWidget, BaseWidget
+
+from pfund_plot.enums import PlottingBackend
+from pfund_plot.plots.plot import BasePlot
+from pfund_plot.widgets.datetime_widget import DatetimeRangeWidget
+from pfund_plot.widgets.ticker_widget import TickerSelectWidget
+
+__all__ = ["Area"]
+
+
+class AreaStyle:
+    from pfund_plot.plots.area.bokeh import style as bokeh_style
+
+    bokeh = bokeh_style
+
+
+class AreaControl:
+    from pfund_plot.plots.area.bokeh import control as bokeh_control
+
+    bokeh = bokeh_control
+
+
+class Area(BasePlot):
+    SUPPORTED_BACKENDS: ClassVar[list[PlottingBackend]] = [PlottingBackend.bokeh]
+    SUPPORT_STREAMING: ClassVar[bool] = True
+    SUPPORTED_WIDGETS: ClassVar[list[type[BaseWidget]]] = [DatetimeRangeWidget]
+    SUPPORTED_STREAMING_WIDGETS: ClassVar[list[type[BaseStreamingWidget]]] = [
+        TickerSelectWidget
+    ]
+    style = AreaStyle
+    control = AreaControl
+
+    def __init__(
+        self,
+        data: IntoFrame | MarketFeed | None = None,
+        x: str | None = None,
+        y: str | list[str] | None = None,
+        y2: str | None = None,
+        callback: Callable[..., Any] | None = None,
+        name: str | None = None,
+        plot_kwargs: dict[str, Any] | None = None,
+        **reactive_params: Any,
+    ):
+        """
+        Args:
+            data: The dataframe for static plot or pfeed's feed object for streaming plot
+            x: Column name for x-positions. If not specified, the index is used.
+                Can refer to continuous and categorical data.
+            y: Column name for the first y-position (lower bound of the area)
+            # REVIEW: y2 is only supported by hvplot
+            y2: Column name for the second y-position (upper bound of the area).
+                If not specified, the area is drawn from 0 to y.
+            callback: A reactive callback function. When provided with **reactive_params,
+                auto-creates widgets that re-fetch data on change.
+            name: Display name for this plot (used as label when widgets are shown alongside overlays).
+                Defaults to the class name lowercased.
+            plot_kwargs: keyword arguments for the plot function.
+                e.g. if the plot function is hvplot.line, plot_kwargs will be passed to hvplot.line(**plot_kwargs)
+            **reactive_params: name=value pairs for reactive widgets (e.g. ticker=["BTC", "ETH"]).
+                Requires callback to be set.
+        """
+        super().__init__(
+            data=data,
+            x=x,
+            y=y,
+            callback=callback,
+            name=name,
+            plot_kwargs=plot_kwargs,
+            **reactive_params,
+        )
+        if y2 is not None:
+            self._plot_kwargs["y2"] = y2

pfund_plot/plots/area/bokeh.py

@@ -0,0 +1,151 @@
+# pyright: reportUnusedParameter=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from holoviews.core.overlay import NdOverlay
+
+import narwhals as nw
+
+from pfund_plot.enums import PlottingBackend
+
+__all__ = ["control", "plot", "style"]
+
+
+DEFAULT_COLOR = "steelblue"
+DEFAULT_HEIGHT = 280
+
+
+def style(
+    title: str = "",
+    xlabel: str = "",
+    ylabel: str = "",
+    color: str = DEFAULT_COLOR,
+    alpha: float = 0.5,
+    marker: Literal[
+        "circle",
+        "square",
+        "triangle_up",
+        "triangle_down",
+        "diamond",
+        "cross",
+        "x",
+        "star",
+    ]
+    | None = None,
+    stacked: bool = True,
+    bg_color: str = "",  # empty string by default because Panel will automatically use the theme color
+    grid: bool = False,
+    total_height: int | None = None,
+    height: int = DEFAULT_HEIGHT,
+    width: int | None = None,
+):
+    """
+    Args:
+        title: the title of the plot
+        xlabel: the label of the x-axis
+        ylabel: the label of the y-axis
+        color: the color of the plot, hex code is supported, only used when there is only one area chart
+        alpha: the alpha of the plot, 0.0 to 1.0
+        marker: marker shape for data points. None hides markers, any value shows them.
+            Default is None (hidden). Options: 'circle', 'square', 'triangle_up',
+            'triangle_down', 'diamond', 'cross', 'x', 'star'.
+        stacked: Whether to stack multiple areas. Default is True.
+        bg_color: the background color of the plot, hex code is supported
+        total_height: the height of the component (including the figure + widgets)
+            Default is None, when it is None, Panel will automatically adjust its height
+        height: the height of the figure
+        width: the width of the plot, since the plot is responsive, this is only used in panel layout
+        grid: whether to show the grid
+    """
+    return locals()
+
+
+def control(
+    num_data: int | None = None,
+    max_data: int | None = None,
+    slider_step: int | None = None,
+    widgets: bool = True,
+    linked_axes: bool = True,
+    update_interval: int = 5000,  # ms
+    incremental_update: bool = True,
+    datetime_precision: Literal["d", "s", "ms"] = "s",
+):
+    """
+    Args:
+        num_data: (DatetimeRangeWidget) initial number of most recent data points to display.
+        max_data: (streaming) maximum number of data points kept in memory.
+            If None, data will continue to grow unbounded.
+        slider_step: (DatetimeRangeWidget) step size in ms for the datetime range slider.
+            If None, derived from data resolution.
+        widgets: whether to show widgets. default is True.
+            For granular control, use remove_widgets() to remove specific widget classes.
+        linked_axes: whether to link axes across plots in a layout (plt.layout(...)).
+        incremental_update: (streaming) whether to update even when the bar is incomplete. default is True.
+        update_interval: (streaming) interval in ms to update the plot. default is 5000 ms.
+        datetime_precision: the precision of datetime formatting on the hover tooltip.
+            "d" for days (%Y-%m-%d), "s" for seconds (default, %Y-%m-%d %H:%M:%S), "ms" for milliseconds (%Y-%m-%d %H:%M:%S.%3N).
+    """
+    return locals()
+
+
+def plot(
+    df: nw.DataFrame[Any],
+    style: dict[str, Any],
+    control: dict[str, Any],
+    x: str | None = None,
+    y: str | list[str] | None = None,
+    **kwargs: Any,
+) -> NdOverlay:
+    import hvplot
+    from bokeh.models import CrosshairTool
+
+    from pfund_plot.plots.area import Area
+
+    _ = hvplot.extension(PlottingBackend.bokeh)
+
+    # resolve y column names
+    x_col = x
+    y_cols = Area._derive_y_cols(df, x, y)
+    datetime_precision = control["datetime_precision"]
+
+    crosshair_tool = CrosshairTool(
+        dimensions="height", line_color="gray", line_alpha=0.3
+    )
+
+    if len(y_cols) == 1:
+        kwargs["color"] = style["color"]
+
+    area_plot = (
+        df.to_native()
+        .hvplot.area(
+            x=x,
+            y=y,
+            tools=[crosshair_tool],
+            grid=style["grid"],
+            bgcolor=style["bg_color"],
+            stacked=style["stacked"],
+            alpha=style["alpha"],
+            responsive=True,
+            # Disable hvplot's built-in hover (shows "???") because hvplot converts
+            # area to Patch polygons, destroying original column data in ColumnDataSource
+            hover=False,
+            **kwargs,
+        )
+        .opts(
+            title=style["title"],
+            xlabel=style["xlabel"],
+            ylabel=style["ylabel"],
+            height=style["height"],
+        )
+    )
+
+    # NOTE: this is not needed if hvplot has fixed the tooltip issue in area plot
+    # Overlay invisible scatter points that carry the real data for hover tooltips
+    from pfund_plot.utils.bokeh import create_hover_scatter
+
+    hover_scatter = create_hover_scatter(
+        df, x_col, y_cols, datetime_precision, marker=style.get("marker")
+    )
+    return area_plot * hover_scatter

pfund_plot/plots/bar/__init__.py

@@ -0,0 +1,80 @@
+# pyright: reportArgumentType=false, reportOptionalMemberAccess=false, reportOptionalSubscript=false, reportCallIssue=false, reportUnknownMemberType=false, reportUnknownVariableType=false, reportUnknownArgumentType=false
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import TYPE_CHECKING, Any, ClassVar
+
+if TYPE_CHECKING:
+    from narwhals.typing import IntoFrame
+    from pfeed.feeds.market_feed import MarketFeed
+
+    from pfund_plot.widgets.base import BaseStreamingWidget, BaseWidget
+
+from pfund_plot.enums import PlottingBackend
+from pfund_plot.plots.plot import BasePlot
+from pfund_plot.widgets.datetime_widget import DatetimeRangeWidget
+from pfund_plot.widgets.ticker_widget import TickerSelectWidget
+
+__all__ = ["Bar"]
+
+
+class BarStyle:
+    from pfund_plot.plots.bar.bokeh import style as bokeh_style
+
+    bokeh = bokeh_style
+
+
+class BarControl:
+    from pfund_plot.plots.bar.bokeh import control as bokeh_control
+
+    bokeh = bokeh_control
+
+
+class Bar(BasePlot):
+    SUPPORTED_BACKENDS: ClassVar[list[PlottingBackend]] = [PlottingBackend.bokeh]
+    SUPPORT_STREAMING: ClassVar[bool] = True
+    SUPPORTED_WIDGETS: ClassVar[list[type[BaseWidget]]] = [DatetimeRangeWidget]
+    SUPPORTED_STREAMING_WIDGETS: ClassVar[list[type[BaseStreamingWidget]]] = [
+        TickerSelectWidget
+    ]
+    style = BarStyle
+    control = BarControl
+
+    def __init__(
+        self,
+        data: IntoFrame | MarketFeed | None = None,
+        x: str | None = None,
+        y: str | list[str] | None = None,
+        by: str | list[str] | None = None,
+        callback: Callable[..., Any] | None = None,
+        name: str | None = None,
+        plot_kwargs: dict[str, Any] | None = None,
+        **reactive_params: Any,
+    ):
+        """
+        Args:
+            data: The dataframe for static plot or pfeed's feed object for streaming plot
+            x: Column name for x-positions. If not specified, the index is used.
+                Can refer to continuous and categorical data.
+            y: Column name for the y-position.
+            by: A single column or list of columns to group by. All the subgroups are visualized.
+            callback: A reactive callback function. When provided with **reactive_params,
+                auto-creates widgets that re-fetch data on change.
+            name: Display name for this plot (used as label when widgets are shown alongside overlays).
+                Defaults to the class name lowercased.
+            plot_kwargs: keyword arguments for the plot function.
+                e.g. if the plot function is hvplot.line, plot_kwargs will be passed to hvplot.line(**plot_kwargs)
+            **reactive_params: name=value pairs for reactive widgets (e.g. ticker=["BTC", "ETH"]).
+                Requires callback to be set.
+        """
+        super().__init__(
+            data=data,
+            x=x,
+            y=y,
+            callback=callback,
+            name=name,
+            plot_kwargs=plot_kwargs,
+            **reactive_params,
+        )
+        if by is not None:
+            self._plot_kwargs["by"] = by

pfund_plot/plots/bar/bokeh.py

@@ -0,0 +1,128 @@
+# pyright: reportUnusedParameter=false
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Literal
+
+if TYPE_CHECKING:
+    from holoviews.core.overlay import Overlay
+
+import narwhals as nw
+
+from pfund_plot.enums import PlottingBackend
+
+__all__ = ["control", "plot", "style"]
+
+
+DEFAULT_COLOR = "steelblue"
+DEFAULT_HEIGHT = 280
+
+
+def style(
+    title: str = "",
+    xlabel: str = "",
+    ylabel: str = "",
+    stacked: bool = False,
+    color: str | list[str] = DEFAULT_COLOR,
+    bg_color: str = "",  # empty string by default because Panel will automatically use the theme color
+    grid: bool = False,
+    total_height: int | None = None,
+    height: int = DEFAULT_HEIGHT,
+    width: int | None = None,
+):
+    """
+    Args:
+        title: the title of the plot
+        xlabel: the label of the x-axis
+        ylabel: the label of the y-axis
+        stacked: Whether to stack multiple bars. Default is False.
+        color: the color of the plot, hex code is supported
+        bg_color: the background color of the plot, hex code is supported
+        total_height: the height of the component (including the figure + widgets)
+            Default is None, when it is None, Panel will automatically adjust its height
+        height: the height of the figure
+        width: the width of the plot, since the plot is responsive, this is only used in panel layout
+        grid: whether to show the grid
+    """
+    return locals()
+
+
+def control(
+    num_data: int | None = None,
+    max_data: int | None = None,
+    slider_step: int | None = None,
+    widgets: bool = True,
+    linked_axes: bool = True,
+    update_interval: int = 5000,  # ms
+    incremental_update: bool = True,
+    datetime_precision: Literal["d", "s", "ms"] = "s",
+):
+    """
+    Args:
+        num_data: (DatetimeRangeWidget) initial number of most recent data points to display.
+        max_data: (streaming) maximum number of data points kept in memory.
+            If None, data will continue to grow unbounded.
+        slider_step: (DatetimeRangeWidget) step size in ms for the datetime range slider.
+            If None, derived from data resolution.
+        widgets: whether to show widgets. default is True.
+            For granular control, use remove_widgets() to remove specific widget classes.
+        linked_axes: whether to link axes across plots in a layout (plt.layout(...)).
+        incremental_update: (streaming) whether to update even when the bar is incomplete. default is True.
+        update_interval: (streaming) interval in ms to update the plot. default is 5000 ms.
+        datetime_precision: the precision of datetime formatting on the hover tooltip.
+            "d" for days (%Y-%m-%d), "s" for seconds (default, %Y-%m-%d %H:%M:%S), "ms" for milliseconds (%Y-%m-%d %H:%M:%S.%3N).
+    """
+    return locals()
+
+
+def plot(
+    df: nw.DataFrame[Any],
+    style: dict[str, Any],
+    control: dict[str, Any],
+    x: str | None = None,
+    y: str | list[str] | None = None,
+    **kwargs: Any,
+) -> Overlay:
+    import hvplot
+    from bokeh.models import CrosshairTool
+
+    from pfund_plot.plots.bar import Bar
+    from pfund_plot.utils.bokeh import create_bundled_hover_tool
+
+    _ = hvplot.extension(PlottingBackend.bokeh)
+
+    x_col = x
+    y_cols = Bar._derive_y_cols(df, x, y)
+    datetime_precision = control["datetime_precision"]
+
+    is_single = len(y_cols) == 1
+    crosshair_tool = CrosshairTool(
+        dimensions="height", line_color="gray", line_alpha=0.3
+    )
+    if is_single:
+        tools = [
+            create_bundled_hover_tool(df, x_col, y_cols, datetime_precision),
+            crosshair_tool,
+        ]
+    else:
+        tools = [crosshair_tool]
+
+    return (
+        df.to_native()
+        .hvplot.bar(
+            x=x,
+            y=y,
+            tools=tools,
+            responsive=True,
+            color=style["color"],
+            stacked=style["stacked"],
+            bgcolor=style["bg_color"],
+            grid=style["grid"],
+            **kwargs,
+        )
+        .opts(
+            title=style["title"],
+            xlabel=style["xlabel"],
+            ylabel=style["ylabel"],
+            height=style["height"],
+        )
+    )

pfund_plot/plots/bokeh.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Literal
+
+if TYPE_CHECKING:
+    from bokeh.model import Model as BokehModel
+
+from pfund_plot.enums import PlottingBackend
+from pfund_plot.plots.plot import BasePlot
+
+
+class Bokeh(BasePlot):
+    SUPPORTED_BACKENDS: ClassVar[list[Literal[PlottingBackend.bokeh]]] = [
+        PlottingBackend.bokeh
+    ]
+    REQUIRED_DATA: ClassVar[bool] = False
+
+    def __init__(
+        self, fig: BokehModel, sizing_mode: str | None = None, **pane_kwargs: Any
+    ):
+        """
+        Args:
+            fig: A Bokeh Model object.
+            sizing_mode: Panel sizing mode: e.g. "stretch_width", "stretch_height", or "stretch_both".
+            **pane_kwargs: Additional keyword arguments passed to pn.pane.Bokeh,
+                e.g. height, width, max_width, margin.
+        """
+        super().__init__(data=None)
+        self._plot: BokehModel = fig
+        self._pane_kwargs = pane_kwargs
+        if sizing_mode is not None:
+            self._pane_kwargs["sizing_mode"] = sizing_mode