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

backtrader/bokeh/tabs/analyzer.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python
+"""
+Analyzer tab.
+
+Displays results of all analyzers.
+"""
+
+from ...utils.log_message import get_logger
+from ..tab import BokehTab
+
+logger = get_logger(__name__)
+
+try:
+    from bokeh.layouts import column
+    from bokeh.models import ColumnDataSource, DataTable, TableColumn
+    from bokeh.models.widgets import Div
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+
+class AnalyzerTab(BokehTab):
+    """Analyzer tab.
+
+    Displays analysis results of all analyzers in the strategy.
+    """
+
+    def _is_useable(self):
+        """Check if useable.
+
+        Useable when strategy has analyzers.
+        """
+        if not BOKEH_AVAILABLE:
+            return False
+        strategy = self.strategy
+        if strategy is None:
+            return False
+        return len(getattr(strategy, "analyzers", [])) > 0
+
+    def _get_panel(self):
+        """Get panel content.
+
+        Returns:
+            tuple: (widget, title)
+        """
+        strategy = self.strategy
+        scheme = self.scheme
+
+        # Create analyzer results display
+        widgets = []
+
+        for analyzer in strategy.analyzers:
+            analyzer_name = analyzer.__class__.__name__
+
+            # Get analysis results
+            try:
+                analysis = analyzer.get_analysis()
+            except Exception:
+                logger.warning("analyzer:56 fallback on Exception")
+                analysis = {}
+
+            # Create title
+            title_div = Div(
+                text=f'<h3 style="color: {scheme.text_color if scheme else "#333"};">{analyzer_name}</h3>',
+                sizing_mode="stretch_width",
+            )
+            widgets.append(title_div)
+
+            # Convert analysis results to table data
+            data = self._flatten_analysis(analysis)
+
+            if data:
+                source = ColumnDataSource(
+                    data={"key": list(data.keys()), "value": [str(v) for v in data.values()]}
+                )
+
+                columns = [
+                    TableColumn(field="key", title="Metric"),
+                    TableColumn(field="value", title="Value"),
+                ]
+
+                table = DataTable(
+                    source=source,
+                    columns=columns,
+                    width=400,
+                    height=min(len(data) * 25 + 30, 300),
+                    index_position=None,
+                )
+                widgets.append(table)
+            else:
+                empty_div = Div(text="<p>No data available</p>")
+                widgets.append(empty_div)
+
+        content = column(*widgets, sizing_mode="stretch_width")
+        return content, "Analyzers"
+
+    def _flatten_analysis(self, analysis, prefix=""):
+        """Flatten nested analysis results.
+
+        Args:
+            analysis: Analysis result dictionary
+            prefix: Key prefix
+
+        Returns:
+            dict: Flattened dictionary
+        """
+        result = {}
+
+        if isinstance(analysis, dict):
+            for key, value in analysis.items():
+                new_key = f"{prefix}.{key}" if prefix else str(key)
+                if isinstance(value, dict):
+                    result.update(self._flatten_analysis(value, new_key))
+                else:
+                    result[new_key] = value
+        else:
+            result[prefix or "value"] = analysis
+
+        return result

backtrader/bokeh/tabs/config.py

@@ -0,0 +1,154 @@
+#!/usr/bin/env python
+"""
+Configuration tab.
+
+Displays configuration info for strategy and data.
+"""
+
+from backtrader.utils.log_message import get_logger
+
+from ..tab import BokehTab
+
+logger = get_logger(__name__)
+
+try:
+    from bokeh.layouts import column
+    from bokeh.models import ColumnDataSource, DataTable, TableColumn
+    from bokeh.models.widgets import Div
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+
+class ConfigTab(BokehTab):
+    """Configuration tab.
+
+    Displays strategy parameters, data configuration and other info.
+    """
+
+    def _is_useable(self):
+        """Config tab is always useable."""
+        return BOKEH_AVAILABLE
+
+    def _get_panel(self):
+        """Get panel content.
+
+        Returns:
+            tuple: (widget, title)
+        """
+        strategy = self.strategy
+        scheme = self.scheme
+
+        widgets = []
+        text_color = scheme.text_color if scheme else "#333"
+
+        # Strategy parameters + data feeds
+        if strategy is not None:
+            widgets.extend(self._build_params_widgets(strategy, text_color))
+            widgets.extend(self._build_data_widgets(strategy, text_color))
+
+        if not widgets:
+            widgets.append(Div(text="<p>No configuration available</p>"))
+
+        content = column(*widgets, sizing_mode="stretch_width")
+        return content, "Config"
+
+    def _build_params_widgets(self, strategy, text_color):
+        """Build the strategy-name heading + parameters table widgets."""
+        widgets = []
+        # Strategy name
+        strategy_name = strategy.__class__.__name__
+        widgets.append(
+            Div(
+                text=f'<h3 style="color: {text_color};">Strategy: {strategy_name}</h3>',
+                sizing_mode="stretch_width",
+            )
+        )
+
+        # Strategy parameters
+        params = {}
+        if hasattr(strategy, "params"):
+            for name in dir(strategy.params):
+                if not name.startswith("_"):
+                    try:
+                        value = getattr(strategy.params, name)
+                        if not callable(value):
+                            params[name] = value
+                    except Exception as e:
+                        logger.warning("Failed to get param '%s': %s", name, e)
+
+        if params:
+            source = ColumnDataSource(
+                data={
+                    "parameter": list(params.keys()),
+                    "value": [str(v) for v in params.values()],
+                }
+            )
+
+            columns = [
+                TableColumn(field="parameter", title="Parameter"),
+                TableColumn(field="value", title="Value"),
+            ]
+
+            table = DataTable(
+                source=source,
+                columns=columns,
+                width=400,
+                height=min(len(params) * 25 + 30, 300),
+                index_position=None,
+            )
+            widgets.append(table)
+        return widgets
+
+    def _build_data_widgets(self, strategy, text_color):
+        """Build the data-feeds heading + data-info table widgets."""
+        widgets = []
+        if hasattr(strategy, "datas") and strategy.datas:
+            widgets.append(
+                Div(
+                    text=f'<h3 style="color: {text_color};">Data Feeds</h3>',
+                    sizing_mode="stretch_width",
+                )
+            )
+
+            data_info = []
+            for i, data in enumerate(strategy.datas):
+                name = data._name if hasattr(data, "_name") else f"Data{i}"
+                length = len(data) if hasattr(data, "__len__") else "N/A"
+                data_info.append(
+                    {
+                        "name": name,
+                        "length": str(length),
+                        "timeframe": str(
+                            getattr(data._timeframe, "name", "N/A")
+                            if hasattr(data, "_timeframe")
+                            else "N/A"
+                        ),
+                    }
+                )
+
+            if data_info:
+                source = ColumnDataSource(
+                    data={
+                        "name": [d["name"] for d in data_info],
+                        "length": [d["length"] for d in data_info],
+                        "timeframe": [d["timeframe"] for d in data_info],
+                    }
+                )
+
+                columns = [
+                    TableColumn(field="name", title="Name"),
+                    TableColumn(field="length", title="Length"),
+                    TableColumn(field="timeframe", title="Timeframe"),
+                ]
+
+                table = DataTable(
+                    source=source,
+                    columns=columns,
+                    width=400,
+                    height=min(len(data_info) * 25 + 30, 200),
+                    index_position=None,
+                )
+                widgets.append(table)
+        return widgets

backtrader/bokeh/tabs/live.py

@@ -0,0 +1,109 @@
+#!/usr/bin/env python
+"""
+Live configuration tab.
+For configuration adjustments in live plotting mode.
+"""
+
+from ..tab import BokehTab
+
+try:
+    from bokeh.layouts import column
+    from bokeh.models.widgets import Button, Div, Select, Slider
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+
+class LiveTab(BokehTab):
+    """Live configuration tab.
+
+    Provides configuration options for live plotting mode:
+    - Lookback adjustment
+    - Auto-refresh interval
+    - Filter options
+    """
+
+    def _is_useable(self):
+        """Useable in live mode."""
+        if not BOKEH_AVAILABLE:
+            return False
+        return self._client is not None
+
+    def _get_panel(self):
+        """Get panel content.
+
+        Returns:
+            tuple: (widget, title)
+        """
+        scheme = self.scheme
+        text_color = scheme.text_color if scheme else "#333"
+
+        widgets = []
+
+        # Title
+        widgets.append(
+            Div(
+                text=f'<h3 style="color: {text_color};">Live Plot Settings</h3>',
+                sizing_mode="stretch_width",
+            )
+        )
+
+        # Lookback settings
+        lookback_value = getattr(self._client, "lookback", 100) if self._client else 100
+        lookback_slider = Slider(
+            start=10, end=500, value=lookback_value, step=10, title="Lookback (candles)", width=300
+        )
+
+        def on_lookback_change(attr, old, new):
+            if self._client is not None:
+                self._client.lookback = new
+
+        lookback_slider.on_change("value", on_lookback_change)
+        widgets.append(lookback_slider)
+
+        # Fill Gaps option
+        fill_gaps = getattr(self._client, "fill_gaps", False) if self._client else False
+        fill_gaps_select = Select(
+            title="Fill Gaps", value="Yes" if fill_gaps else "No", options=["Yes", "No"], width=150
+        )
+
+        def on_fill_gaps_change(attr, old, new):
+            if self._client is not None:
+                self._client.fill_gaps = new == "Yes"
+
+        fill_gaps_select.on_change("value", on_fill_gaps_change)
+        widgets.append(fill_gaps_select)
+
+        # Plot Group settings
+        plotgroup = getattr(self._client, "plotgroup", "") if self._client else ""
+        plotgroup_select = Select(
+            title="Plot Group",
+            value=plotgroup or "All",
+            options=["All"],  # Can dynamically add more options
+            width=200,
+        )
+        widgets.append(plotgroup_select)
+
+        # Refresh button
+        refresh_btn = Button(label="Refresh", button_type="primary", width=100)
+
+        def on_refresh_click():
+            if self._client is not None:
+                self._client.updatemodel()
+
+        refresh_btn.on_click(on_refresh_click)
+        widgets.append(refresh_btn)
+
+        # Status info
+        status_text = (
+            "Running" if self._client and not getattr(self._client, "_paused", True) else "Paused"
+        )
+        status_div = Div(
+            text=f'<p style="color: {text_color};">Status: <strong>{status_text}</strong></p>',
+            sizing_mode="stretch_width",
+        )
+        widgets.append(status_div)
+
+        content = column(*widgets, sizing_mode="stretch_width")
+        return content, "Live"

backtrader/bokeh/tabs/log.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+"""
+Log tab.
+
+Displays strategy execution logs.
+"""
+
+import logging
+from collections import deque
+
+from ..tab import BokehTab
+
+try:
+    from bokeh.layouts import column
+    from bokeh.models import ColumnDataSource, DataTable, TableColumn
+    from bokeh.models.widgets import Div
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+# Global log storage
+_log_storage: dict = {}
+
+
+class LogHandler(logging.Handler):
+    """Log handler.
+
+    Captures log messages and stores them in specified storage.
+    """
+
+    def __init__(self, storage_key, max_records=1000):
+        """Initialize log handler.
+
+        Args:
+            storage_key: Key to identify log storage in global dictionary.
+            max_records: Maximum number of log records to keep (default: 1000).
+        """
+        super().__init__()
+        self.storage_key = storage_key
+        self.max_records = max_records
+        if storage_key not in _log_storage:
+            _log_storage[storage_key] = deque(maxlen=max_records)
+
+    def emit(self, record):
+        """Emit a log record.
+
+        Args:
+            record: Log record to process.
+        """
+        log_entry = {
+            "time": self.format(record).split(" - ")[0] if " - " in self.format(record) else "",
+            "level": record.levelname,
+            "message": record.getMessage(),
+        }
+        _log_storage[self.storage_key].append(log_entry)
+
+
+def getlogger(name="backtrader", col=None):
+    """Get logger with log handler.
+
+    Args:
+        name: Logger name
+        col: Custom columns (optional)
+
+    Returns:
+        logging.Logger instance
+    """
+    logger = logging.getLogger(name)
+
+    # Check if LogHandler already added
+    has_handler = any(isinstance(h, LogHandler) for h in logger.handlers)
+    if not has_handler:
+        handler = LogHandler(name)
+        handler.setFormatter(logging.Formatter("%(asctime)s - %(levelname)s - %(message)s"))
+        logger.addHandler(handler)
+
+    return logger
+
+
+class LogTab(BokehTab):
+    """Log tab.
+
+    Displays log information during strategy execution.
+
+    Attributes:
+        cols: Column configuration for display
+    """
+
+    cols = ["Time", "Level", "Message"]  # Default columns
+
+    def __init__(self, app, figurepage, client=None, cols=None):
+        """Initialize log tab.
+
+        Args:
+            app: Bokeh application instance.
+            figurepage: Figure page instance.
+            client: Optional client instance.
+            cols: Custom column configuration for log display.
+        """
+        super().__init__(app, figurepage, client)
+        if cols is not None:
+            self.cols = cols
+
+    def _is_useable(self):
+        """Log tab is always useable."""
+        return BOKEH_AVAILABLE
+
+    def _get_panel(self):
+        """Get panel content.
+
+        Returns:
+            tuple: (widget, title)
+        """
+        scheme = self.scheme
+        text_color = scheme.text_color if scheme else "#333"
+
+        widgets = []
+
+        # Title
+        widgets.append(
+            Div(
+                text=f'<h3 style="color: {text_color};">Log Messages</h3>',
+                sizing_mode="stretch_width",
+            )
+        )
+
+        # Get log data
+        log_data = self._get_log_data()
+
+        if log_data:
+            # Create data source
+            source = ColumnDataSource(data=log_data)
+
+            # Create columns
+            columns = []
+            for col_name in log_data.keys():
+                columns.append(TableColumn(field=col_name, title=col_name.capitalize()))
+
+            # Create table
+            table = DataTable(
+                source=source, columns=columns, width=800, height=400, index_position=None
+            )
+            widgets.append(table)
+        else:
+            widgets.append(Div(text="<p>No log messages available</p>"))
+
+        content = column(*widgets, sizing_mode="stretch_width")
+        return content, "Log"
+
+    def _get_log_data(self):
+        """Get log data.
+
+        Returns:
+            dict: Log data dictionary
+        """
+        # Get data from global log storage
+        all_logs = []
+        for key, logs in _log_storage.items():
+            all_logs.extend(list(logs))
+
+        if not all_logs:
+            return None
+
+        # Sort by time (newest first)
+        all_logs = list(reversed(all_logs))
+
+        # Convert to column data format
+        return {
+            "time": [log.get("time", "") for log in all_logs],
+            "level": [log.get("level", "") for log in all_logs],
+            "message": [log.get("message", "") for log in all_logs],
+        }
+
+
+def LogTabs(cols):
+    """Create log tab class with custom columns.
+
+    Args:
+        cols: Column configuration
+
+    Returns:
+        Custom LogTab class
+    """
+    return type("LogTab", (LogTab,), {"cols": cols})