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

backtrader/bokeh/utils/helpers.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python
+"""
+Helper utility functions.
+"""
+
+import re
+from typing import List
+
+from backtrader.utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+
+def get_datanames(strategy):
+    """Get names of all data sources in strategy.
+
+    Args:
+        strategy: Strategy instance
+
+    Returns:
+        list: List of data source names
+    """
+    datanames: List[str] = []
+
+    if strategy is None or not hasattr(strategy, "datas"):
+        return datanames
+
+    for i, data in enumerate(strategy.datas):
+        if hasattr(data, "_name") and data._name:
+            datanames.append(data._name)
+        else:
+            datanames.append(f"Data{i}")
+
+    return datanames
+
+
+def get_strategy_label(strategy):
+    """Get strategy label.
+
+    Args:
+        strategy: Strategy instance
+
+    Returns:
+        str: Strategy label
+    """
+    if strategy is None:
+        return "Unknown Strategy"
+
+    return strategy.__class__.__name__
+
+
+def sanitize_source_name(name):
+    """Sanitize data source name, remove illegal characters.
+
+    Args:
+        name: Original name
+
+    Returns:
+        str: Sanitized name
+    """
+    if name is None:
+        return "unnamed"
+
+    # Remove non-alphanumeric and underscore characters
+    sanitized = re.sub(r"[^a-zA-Z0-9_]", "_", str(name))
+
+    # Ensure it doesn't start with a digit
+    if sanitized and sanitized[0].isdigit():
+        sanitized = "_" + sanitized
+
+    return sanitized or "unnamed"
+
+
+def get_indicator_label(indicator):
+    """Get indicator label.
+
+    Args:
+        indicator: Indicator instance
+
+    Returns:
+        str: Indicator label
+    """
+    if indicator is None:
+        return "Unknown Indicator"
+
+    label = indicator.__class__.__name__
+
+    # Add parameter info (if available)
+    if hasattr(indicator, "params"):
+        params = []
+        for name in dir(indicator.params):
+            if not name.startswith("_"):
+                try:
+                    value = getattr(indicator.params, name)
+                    if not callable(value):
+                        params.append(f"{name}={value}")
+                except Exception as e:
+                    logger.warning("Failed to get indicator param '%s': %s", name, e)
+        if params:
+            label += f" ({', '.join(params[:3])})"  # Show max 3 parameters
+
+    return label
+
+
+def format_datetime(dt, fmt="%Y-%m-%d %H:%M"):
+    """Format datetime.
+
+    Args:
+        dt: datetime object
+        fmt: Format string
+
+    Returns:
+        str: Formatted string
+    """
+    if dt is None:
+        return ""
+
+    try:
+        return dt.strftime(fmt)
+    except Exception:
+        logger.warning("helpers:120 fallback on Exception")
+        return str(dt)
+
+
+def format_number(value, precision=2):
+    """Format number.
+
+    Args:
+        value: Numeric value
+        precision: Decimal precision
+
+    Returns:
+        str: Formatted string
+    """
+    if value is None:
+        return "N/A"
+
+    try:
+        return f"{float(value):.{precision}f}"
+    except (ValueError, TypeError):
+        return str(value)
+
+
+def get_color_from_value(value, up_color="#26a69a", down_color="#ef5350", neutral_color="#666666"):
+    """Get color based on value.
+
+    Args:
+        value: Numeric value
+        up_color: Color for positive values
+        down_color: Color for negative values
+        neutral_color: Color for zero values
+
+    Returns:
+        str: Color value
+    """
+    if value is None:
+        return neutral_color
+
+    try:
+        val = float(value)
+        if val > 0:
+            return up_color
+        if val < 0:
+            return down_color
+        return neutral_color
+    except (ValueError, TypeError):
+        return neutral_color

backtrader/bokeh/webapp.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+"""Web application server.
+
+Provides Bokeh Server wrapper."""
+
+import webbrowser
+
+from backtrader.utils.log_message import get_logger
+
+try:
+    from bokeh.application import Application
+    from bokeh.application.handlers import FunctionHandler
+    from bokeh.server.server import Server
+
+    BOKEH_AVAILABLE = True
+except ImportError:
+    BOKEH_AVAILABLE = False
+
+_logger = get_logger(__name__)
+
+
+class Webapp:
+    """Web application server.
+
+    Wraps Bokeh Server, providing the following features:
+    - Auto-start server
+    - Session management
+    - Auto-open browser
+
+    Attributes:
+        title: Page title
+        template: Template filename
+        scheme: Theme instance
+        address: Server address
+        port: Server port
+    """
+
+    def __init__(
+        self,
+        title,
+        template,
+        scheme,
+        on_root_model,
+        on_session_destroyed=None,
+        autostart=True,
+        address="localhost",
+        port=8999,
+    ):
+        """Initialize web application.
+
+        Args:
+            title: Page title
+            template: Template filename
+            scheme: Theme instance
+            on_root_model: Callback function to build root model
+            on_session_destroyed: Session destroyed callback (optional)
+            autostart: Whether to auto-start
+            address: Server address
+            port: Server port
+        """
+        self._title = title
+        self._template = template
+        self._scheme = scheme
+        self._on_root_model = on_root_model
+        self._on_session_destroyed = on_session_destroyed
+        self._autostart = autostart
+        self._address = address
+        self._port = port
+        self._server = None
+
+    def _make_document(self, doc):
+        """Create Bokeh document.
+
+        Args:
+            doc: Bokeh document instance
+        """
+        # Set title
+        doc.title = self._title
+
+        # Set session destroyed callback
+        if self._on_session_destroyed is not None:
+            doc.on_session_destroyed(self._on_session_destroyed)
+
+        # Build root model
+        root_model = self._on_root_model(doc)
+
+        if root_model is not None:
+            doc.add_root(root_model)
+
+        # Apply theme styles
+        if self._scheme is not None:
+            self._apply_theme(doc)
+
+    def _apply_theme(self, doc):
+        """Apply theme to document.
+
+        Args:
+            doc: Bokeh document instance
+        """
+        # Set background color and other styles
+        if hasattr(self._scheme, "body_background_color"):
+            # Set page styles via CSS
+            from bokeh.models import Div
+
+            style_html = f"""
+            <style>
+                body {{
+                    background-color: {self._scheme.body_background_color};
+                    color: {getattr(self._scheme, "text_color", "#333")};
+                }}
+                .bk-root {{
+                    background-color: {self._scheme.body_background_color};
+                }}
+            </style>
+            """
+            style_div = Div(text=style_html, visible=False)
+            doc.add_root(style_div)
+
+    def start(self, loop=None):
+        """Start server.
+
+        Args:
+            loop: Tornado IOLoop (optional)
+        """
+        if not BOKEH_AVAILABLE:
+            _logger.error("Bokeh is not available. Cannot start server.")
+            return
+
+        _logger.info(f"Starting Bokeh server at http://{self._address}:{self._port}")
+
+        # Create application
+        handler = FunctionHandler(self._make_document)
+        app = Application(handler)
+
+        # Create server
+        self._server = Server(
+            {"/": app},
+            address=self._address,
+            port=self._port,
+            allow_websocket_origin=[
+                f"{self._address}:{self._port}",
+                "localhost:" + str(self._port),
+            ],
+        )
+
+        self._server.start()
+
+        # Auto-open browser
+        if self._autostart:
+            url = f"http://{self._address}:{self._port}/"
+            _logger.info(f"Opening browser at {url}")
+            webbrowser.open(url)
+
+        # Start IOLoop
+        if loop is not None:
+            loop.start()
+        else:
+            self._server.io_loop.start()
+
+    def stop(self):
+        """Stop server."""
+        if self._server is not None:
+            self._server.stop()
+            _logger.info("Bokeh server stopped")