back-trader-python 1.4.0__py3-none-any.whl

backtrader/bokeh/live/__init__.py

@@ -0,0 +1,11 @@
+#!/usr/bin/env python
+"""
+Live functionality module.
+
+Provides real-time data processing and client management functionality.
+"""
+
+from .client import LiveClient
+from .datahandler import LiveDataHandler
+
+__all__ = ["LiveClient", "LiveDataHandler"]

backtrader/bokeh/live/client.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python
+"""
+Live client.
+
+Manages Bokeh documents and user interactions.
+"""
+
+from backtrader.utils.log_message import get_logger
+
+try:
+    from bokeh.layouts import column, layout, row
+    from bokeh.models import Button, Select, Spacer, Tabs
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+from ..utils import get_datanames
+from .datahandler import LiveDataHandler
+
+_logger = get_logger(__name__)
+
+
+class LiveClient:
+    """Live client.
+
+    Provides real-time plotting functionality, including:
+    - Data filtering
+    - Navigation controls (pause/play/forward/backward)
+    - Data updates
+
+    Attributes:
+        doc: Bokeh document instance
+        model: Bokeh root model
+        lookback: Historical data retention
+        fill_gaps: Whether to fill data gaps
+        plotgroup: Plot group for filtering
+    """
+
+    NAV_BUTTON_WIDTH = 38
+
+    def __init__(self, doc, app, strategy, lookback):
+        """Initialize live client.
+
+        Args:
+            doc: Bokeh document instance
+            app: BacktraderBokeh application instance
+            strategy: Strategy instance
+            lookback: Historical data retention
+        """
+        self._app = app
+        self._strategy = strategy
+        self._refresh_fnc = None
+        self._datahandler = None
+        self._figurepage = None
+        self._paused = False
+        self._filter = ""
+
+        # plotgroup for filter
+        self.plotgroup = ""
+        # amount of candles to plot
+        self.lookback = lookback
+        # should gaps in data be filled
+        self.fill_gaps = False
+        # bokeh document for client
+        self.doc = doc
+        # model is the root model for bokeh and will be set in baseapp
+        self.model = None
+
+        # append config tab if default tabs should be added
+        if hasattr(self._app, "p") and getattr(self._app.p, "use_default_tabs", True):
+            from ..tabs import LiveTab
+
+            if LiveTab not in self._app.tabs:
+                self._app.tabs.append(LiveTab)
+
+        # set plotgroup from app params if provided
+        if hasattr(self._app, "p") and hasattr(self._app.p, "filter"):
+            if self._app.p.filter and self._app.p.filter.get("group"):
+                self.plotgroup = self._app.p.filter["group"]
+
+        # create figurepage
+        self._figid, self._figurepage = self._app.create_figurepage(self._strategy, filldata=False)
+
+        # create model
+        self.model, self._refresh_fnc = self._createmodel()
+
+        # update model with current figurepage
+        self.updatemodel()
+
+    def _createmodel(self):
+        """Create Bokeh model.
+
+        Returns:
+            tuple: (model, refresh_function)
+        """
+        if not BOKEH_AVAILABLE:
+            return None, None
+
+        client = self
+
+        def on_select_filter(a, old, new):
+            _logger.debug(f"Switching filter to {new}...")
+            # ensure datahandler is stopped
+            if client._datahandler is not None:
+                client._datahandler.stop()
+            client._filter = new
+            client.updatemodel()
+            _logger.debug("Switching filter finished")
+
+        def on_click_nav_action():
+            if not client._paused:
+                client._pause()
+            else:
+                client._resume()
+            refresh()
+
+        def on_click_nav_prev(steps=1):
+            client._pause()
+            client._set_data_by_idx(client._datahandler.get_last_idx() - steps)
+            update_nav_buttons()
+
+        def on_click_nav_next(steps=1):
+            client._pause()
+            client._set_data_by_idx(client._datahandler.get_last_idx() + steps)
+            update_nav_buttons()
+
+        def refresh():
+            client.doc.add_next_tick_callback(update_nav_buttons)
+
+        def reset_nav_buttons():
+            btn_nav_prev.disabled = True
+            btn_nav_next.disabled = True
+            btn_nav_action.label = "❙❙"
+
+        def update_nav_buttons():
+            if client._datahandler is None:
+                return
+
+            last_idx = client._datahandler.get_last_idx()
+            last_avail_idx = client._app.get_last_idx(client._figid)
+
+            if last_idx < client.lookback:
+                btn_nav_prev.disabled = True
+                btn_nav_prev_big.disabled = True
+            else:
+                btn_nav_prev.disabled = False
+                btn_nav_prev_big.disabled = False
+
+            if last_idx >= last_avail_idx:
+                btn_nav_next.disabled = True
+                btn_nav_next_big.disabled = True
+            else:
+                btn_nav_next.disabled = False
+                btn_nav_next_big.disabled = False
+
+            if client._paused:
+                btn_nav_action.label = "▶"
+            else:
+                btn_nav_action.label = "❙❙"
+
+        # filter selection
+        datanames = get_datanames(self._strategy)
+        options = [("", "Strategy")]
+        for d in datanames:
+            options.append(("D" + d, f"Data: {d}"))
+        options.append(("G", "Plot Group"))
+
+        self._filter = "D" + datanames[0] if datanames else ""
+
+        select_filter = Select(value=self._filter, options=options, width=200)
+        select_filter.on_change("value", on_select_filter)
+
+        # navigation buttons
+        btn_nav_prev = Button(label="❮", width=self.NAV_BUTTON_WIDTH)
+        btn_nav_prev.on_click(lambda: on_click_nav_prev(1))
+
+        btn_nav_prev_big = Button(label="❮❮", width=self.NAV_BUTTON_WIDTH)
+        btn_nav_prev_big.on_click(lambda: on_click_nav_prev(10))
+
+        btn_nav_action = Button(label="❙❙", width=self.NAV_BUTTON_WIDTH)
+        btn_nav_action.on_click(on_click_nav_action)
+
+        btn_nav_next = Button(label="❯", width=self.NAV_BUTTON_WIDTH)
+        btn_nav_next.on_click(lambda: on_click_nav_next(1))
+
+        btn_nav_next_big = Button(label="❯❯", width=self.NAV_BUTTON_WIDTH)
+        btn_nav_next_big.on_click(lambda: on_click_nav_next(10))
+
+        # layout
+        controls = row(children=[select_filter])
+        nav = row(
+            children=[
+                btn_nav_prev_big,
+                btn_nav_prev,
+                btn_nav_action,
+                btn_nav_next,
+                btn_nav_next_big,
+            ]
+        )
+
+        # tabs
+        tabs = Tabs(
+            tabs=[],
+            sizing_mode=(
+                self._app.scheme.plot_sizing_mode
+                if hasattr(self._app, "scheme")
+                else "stretch_width"
+            ),
+        )
+        tabs.name = "tabs"
+
+        # model
+        model = layout(
+            [
+                # app settings, top area
+                [column(controls, width_policy="min"), Spacer(), column(nav, width_policy="min")],
+                Spacer(height=15),
+                # layout for tabs
+                [tabs],
+            ],
+            sizing_mode="stretch_width",
+        )
+
+        return model, refresh
+
+    def updatemodel(self):
+        """Update model."""
+        if not BOKEH_AVAILABLE or self.doc is None:
+            return
+
+        self.doc.hold()
+
+        # update figurepage with filter
+        self._app.update_figurepage(filter=self._get_filter())
+
+        # generate panels
+        panels = self._app.generate_model_panels()
+
+        # add tab panels
+        for t in self._app.tabs:
+            tab = t(self._app, self._figurepage, self)
+            if tab.is_useable():
+                panels.append(tab.get_panel())
+
+        # set all tabs (filter out None)
+        tabs = self._get_tabs()
+        if tabs is not None:
+            tabs.tabs = [p for p in panels if p is not None]
+
+        # create new data handler
+        if self._datahandler is not None:
+            self._datahandler.stop()
+
+        self._datahandler = LiveDataHandler(
+            doc=self.doc,
+            app=self._app,
+            figid=self._figid,
+            lookback=self.lookback,
+            fill_gaps=self.fill_gaps,
+        )
+
+        # refresh model
+        if self._refresh_fnc is not None:
+            self._refresh_fnc()
+
+        self.doc.unhold()
+
+    def _get_filter(self):
+        """Get current filter settings.
+
+        Returns:
+            dict: Filter configuration
+        """
+        res = {}
+        if self._filter.startswith("D"):
+            res["dataname"] = self._filter[1:]
+        elif self._filter.startswith("G"):
+            res["group"] = self.plotgroup
+        return res
+
+    def _pause(self):
+        """Pause data updates."""
+        self._paused = True
+
+    def _resume(self):
+        """Resume data updates."""
+        if not self._paused:
+            return
+        if self._datahandler is not None:
+            self._datahandler.update()
+        self._paused = False
+
+    def _set_data_by_idx(self, idx=None):
+        """Set data by index.
+
+        Args:
+            idx: Data index (optional)
+        """
+        if idx is not None:
+            # Ensure index is within valid range
+            last_avail_idx = self._app.get_last_idx(self._figid)
+            idx = min(idx, last_avail_idx)
+            idx = max(idx, self.lookback - 1)
+
+        # Generate data
+        df = self._app.generate_data(
+            figid=self._figid,
+            end=idx,
+            back=self.lookback,
+            preserveidx=True,
+            fill_gaps=self.fill_gaps,
+        )
+
+        if self._datahandler is not None:
+            self._datahandler.set(df)
+
+    def _get_tabs(self):
+        """Get Tabs component.
+
+        Returns:
+            Tabs instance or None
+        """
+        if self.model is None:
+            return None
+
+        # Find component named 'tabs'
+        for child in self.model.children:
+            if hasattr(child, "__iter__"):
+                for item in child:
+                    if hasattr(item, "name") and item.name == "tabs":
+                        return item
+                    if isinstance(item, Tabs):
+                        return item
+
+        return None
+
+    def next(self):
+        """Receive new data and update.
+
+        Called by LivePlotAnalyzer.next()
+        """
+        if not self._paused and self._datahandler is not None:
+            self._datahandler.update()
+
+        if self._refresh_fnc is not None:
+            self._refresh_fnc()
+
+    def stop(self):
+        """Stop client."""
+        if self._datahandler is not None:
+            self._datahandler.stop()

backtrader/bokeh/live/datahandler.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python
+"""
+Live data handler.
+
+Handles real-time data updates and pushes.
+"""
+
+import importlib.util
+import time
+from enum import Enum
+from threading import Lock, Thread
+
+from backtrader.utils.log_message import get_logger
+
+TORNADO_AVAILABLE = importlib.util.find_spec("tornado") is not None
+
+try:
+    import pandas as pd
+
+    PANDAS_AVAILABLE = True
+except ImportError:
+    PANDAS_AVAILABLE = False
+
+_logger = get_logger(__name__)
+
+
+class UpdateType(Enum):
+    """Data update type."""
+
+    ADD = 1  # Add new data
+    UPDATE = 2  # Update existing data
+
+
+class LiveDataHandler:
+    """Live data handler.
+
+    Responsible for receiving, storing and pushing real-time data.
+
+    Attributes:
+        _doc: Bokeh document
+        _app: BacktraderBokeh application
+        _figid: Figure page ID
+        _lookback: Historical data retention
+        _fill_gaps: Whether to fill data gaps
+    """
+
+    def __init__(self, doc, app, figid, lookback, fill_gaps=True, timeout=1):
+        """Initialize data handler.
+
+        Args:
+            doc: Bokeh document
+            app: BacktraderBokeh application
+            figid: Figure page ID
+            lookback: Historical data retention
+            fill_gaps: Whether to fill data gaps
+            timeout: Thread timeout
+        """
+        self._doc = doc
+        self._app = app
+        self._figid = figid
+        self._lookback = lookback
+        self._fill_gaps = fill_gaps
+        self._timeout = timeout
+
+        # Get figurepage
+        self._figurepage = app.get_figurepage(figid)
+
+        # Thread related
+        self._thread = Thread(target=self._t_thread, daemon=True)
+        self._lock = Lock()
+        self._running = True
+        self._new_data = False
+
+        # Data storage
+        self._datastore = None
+        self._last_idx = -1
+        self._patches = []
+
+        # Callbacks
+        self._cb_patch = None
+        self._cb_add = None
+
+        # Initial data fill
+        self._fill()
+
+        # Start thread
+        self._thread.start()
+
+    def _fill(self):
+        """Fill initial data."""
+        if not PANDAS_AVAILABLE:
+            return
+
+        df = self._app.generate_data(
+            figid=self._figid, back=self._lookback, preserveidx=True, fill_gaps=self._fill_gaps
+        )
+
+        self._set_data(df)
+
+        # Initialize CDS columns
+        if self._figurepage is not None and hasattr(self._figurepage, "set_cds_columns_from_df"):
+            self._figurepage.set_cds_columns_from_df(self._datastore)
+
+    def _set_data(self, data, idx=None):
+        """Set or append data.
+
+        Args:
+            data: DataFrame or Series
+            idx: Index (for updating specific row)
+        """
+        if not PANDAS_AVAILABLE:
+            return
+
+        with self._lock:
+            if isinstance(data, pd.DataFrame):
+                self._datastore = data
+                self._last_idx = -1
+            elif isinstance(data, pd.Series):
+                if idx is None:
+                    self._datastore = pd.concat([self._datastore, data.to_frame().T])
+                else:
+                    self._datastore.loc[idx] = data
+            else:
+                _logger.warning(f"Unsupported data type: {type(data)}")
+                return
+
+            # Keep data length within lookback range
+            if self._datastore is not None:
+                self._datastore = self._datastore.tail(self._get_data_stream_length())
+
+    def _cb_push_adds(self):
+        """Push new data to ColumnDataSources."""
+        if self._datastore is None or "index" not in self._datastore.columns:
+            return
+
+        # Get data not yet pushed
+        update_df = self._datastore[self._datastore["index"] > self._last_idx]
+
+        if update_df.shape[0] == 0:
+            return
+
+        # Update last pushed index
+        self._last_idx = update_df["index"].iloc[-1]
+
+        fp = self._figurepage
+        if fp is None:
+            return
+
+        # Push to figurepage
+        if hasattr(fp, "get_cds_streamdata_from_df") and hasattr(fp, "cds"):
+            data = fp.get_cds_streamdata_from_df(update_df)
+            if data:
+                _logger.debug(f"Streaming data to figurepage: {len(data)} columns")
+                fp.cds.stream(data, self._get_data_stream_length())
+
+        # Push to each figure
+        if hasattr(fp, "figures"):
+            for f in fp.figures:
+                if hasattr(f, "get_cds_streamdata_from_df") and hasattr(f, "cds"):
+                    data = f.get_cds_streamdata_from_df(update_df)
+                    if data:
+                        f.cds.stream(data, self._get_data_stream_length())
+
+    def _cb_push_patches(self):
+        """Push patch data to ColumnDataSources."""
+        patches = []
+        while len(self._patches) > 0:
+            patches.append(self._patches.pop(0))
+
+        if len(patches) == 0:
+            return
+
+        fp = self._figurepage
+        if fp is None:
+            return
+
+        for patch in patches:
+            # Patch figurepage
+            if hasattr(fp, "get_cds_patchdata_from_series") and hasattr(fp, "cds"):
+                p_data, s_data = fp.get_cds_patchdata_from_series(patch)
+                if len(p_data) > 0:
+                    _logger.debug(f"Patching figurepage: {len(p_data)} fields")
+                    fp.cds.patch(p_data)
+                if len(s_data) > 0:
+                    fp.cds.stream(s_data, self._get_data_stream_length())
+
+            # Patch all figures
+            if hasattr(fp, "figures"):
+                for f in fp.figures:
+                    if not hasattr(f, "get_cds_patchdata_from_series") or not hasattr(f, "cds"):
+                        continue
+
+                    # Determine whether to fill NaN
+                    c_fill_nan = []
+                    if not self._fill_gaps and hasattr(f, "fill_nan"):
+                        c_fill_nan = f.fill_nan()
+
+                    p_data, s_data = f.get_cds_patchdata_from_series(patch, c_fill_nan)
+                    if len(p_data) > 0:
+                        f.cds.patch(p_data)
+                    if len(s_data) > 0:
+                        f.cds.stream(s_data, self._get_data_stream_length())
+
+    def _push_adds(self):
+        """Trigger new data push."""
+        if self._doc is None:
+            return
+
+        try:
+            if self._cb_add is not None:
+                self._doc.remove_next_tick_callback(self._cb_add)
+        except ValueError:
+            # Callback was already consumed/removed by Bokeh; nothing to undo.
+            _logger.debug("datahandler:214 ignored ValueError")
+
+        self._cb_add = self._doc.add_next_tick_callback(self._cb_push_adds)
+
+    def _push_patches(self):
+        """Trigger patch data push."""
+        if self._doc is None:
+            return
+
+        try:
+            if self._cb_patch is not None:
+                self._doc.remove_next_tick_callback(self._cb_patch)
+        except ValueError:
+            # Callback was already consumed/removed by Bokeh; nothing to undo.
+            _logger.debug("datahandler:228 ignored ValueError")
+
+        self._cb_patch = self._doc.add_next_tick_callback(self._cb_push_patches)
+
+    def _process(self, rows):
+        """Process new data rows.
+
+        Args:
+            rows: DataFrame containing new data
+        """
+        if not PANDAS_AVAILABLE or rows is None:
+            return
+
+        for idx, row in rows.iterrows():
+            if (
+                self._datastore is not None
+                and self._datastore.shape[0] > 0
+                and "index" in self._datastore.columns
+                and idx in self._datastore["index"].values
+            ):
+                update_type = UpdateType.UPDATE
+            else:
+                update_type = UpdateType.ADD
+
+            if update_type == UpdateType.UPDATE:
+                ds_idx = self._datastore.loc[self._datastore["index"] == idx].index[0]
+                self._set_data(row, ds_idx)
+                self._patches.append(row)
+                self._push_patches()
+            else:
+                self._set_data(row)
+                self._push_adds()
+
+    def _t_thread(self):
+        """Data processing thread."""
+        while self._running:
+            if self._new_data:
+                last_idx = self.get_last_idx()
+                last_avail_idx = self._app.get_last_idx(self._figid)
+
+                if last_avail_idx - last_idx > (2 * self._lookback):
+                    # If new data exceeds lookback length, load from end
+                    data = self._app.generate_data(
+                        figid=self._figid,
+                        back=self._lookback,
+                        preserveidx=True,
+                        fill_gaps=self._fill_gaps,
+                    )
+                else:
+                    # Otherwise load from last index
+                    data = self._app.generate_data(
+                        figid=self._figid,
+                        start=last_idx,
+                        preserveidx=True,
+                        fill_gaps=self._fill_gaps,
+                    )
+
+                self._new_data = False
+                self._process(data)
+
+            time.sleep(self._timeout)
+
+    def _get_data_stream_length(self):
+        """Get data stream length.
+
+        Returns:
+            int: Data stream length
+        """
+        if self._datastore is None:
+            return self._lookback
+        return min(self._lookback, self._datastore.shape[0])
+
+    def get_last_idx(self):
+        """Get last data index.
+
+        Returns:
+            int: Last index, returns -1 if no data
+        """
+        if self._datastore is not None and self._datastore.shape[0] > 0:
+            if "index" in self._datastore.columns:
+                return self._datastore["index"].iloc[-1]
+        return -1
+
+    def set(self, df):
+        """Set new DataFrame and push.
+
+        Args:
+            df: New DataFrame
+        """
+        self._set_data(df)
+        self._push_adds()
+
+    def update(self):
+        """Notify that new data is available."""
+        if self._running:
+            self._new_data = True
+
+    def stop(self):
+        """Stop data handler."""
+        self._running = False
+
+        # Remove pending callbacks
+        try:
+            if self._cb_patch is not None:
+                self._doc.remove_next_tick_callback(self._cb_patch)
+        except (ValueError, AttributeError):
+            # Callback already gone or doc detached during shutdown; ignore.
+            _logger.debug("datahandler:335 ignored ValueError,AttributeError")
+
+        try:
+            if self._cb_add is not None:
+                self._doc.remove_next_tick_callback(self._cb_add)
+        except (ValueError, AttributeError):
+            # Callback already gone or doc detached during shutdown; ignore.
+            _logger.debug("datahandler:342 ignored ValueError,AttributeError")
+
+        # Wait for thread to finish
+        if self._thread.is_alive():
+            self._thread.join(timeout=0.5)