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

backtrader/_cerebro/execution.py

@@ -0,0 +1,377 @@
+"""Cerebro run orchestration mixin (iteration 28 split).
+
+Moved verbatim from ``backtrader/cerebro.py``: strategy instantiation
+preparation, runstrategies orchestration, writers and shared helpers.
+"""
+
+import itertools
+import logging
+import time
+
+from .. import errors, observers
+from ..metabase import OwnerContext
+from ..utils import OrderedDict, tzparse
+from ..utils.log_message import _is_output_enabled_for, get_logger
+from ..utils.py3 import integer_types
+
+# Keep the historical logger name (D28-04.6): routing/filters must not change.
+logger = get_logger("backtrader.cerebro")
+
+
+class ExecutionMixin:
+    """Run orchestration half of Cerebro (see module docstring)."""
+
+    def _read_broker_lifecycle_value(self, accessor):
+        """Read an optional broker summary without changing the run outcome.
+
+        Lifecycle INFO logging is opt-in.  A custom broker can legitimately
+        expose cash/value only after ``start()`` or before ``stop()``.  The
+        summary is diagnostic data, so an unavailable accessor must not make
+        a backtest fail.
+        """
+        try:
+            return getattr(self._broker, accessor)()
+        except Exception:
+            # Broker implementations can raise third-party exceptions carrying
+            # account or transport details.  This optional summary must never
+            # copy that unknown payload into a framework log.
+            logger.warning("broker %s unavailable for lifecycle logging", accessor)
+            return None
+
+    def _read_data_lifecycle_length(self, data):
+        """Read a data length only while its lifecycle is still active."""
+        try:
+            return len(data)
+        except Exception:
+            # ``data`` can be a live feed whose ``stop()`` releases buffers.
+            # Keep the event useful without writing a third-party traceback.
+            logger.warning("data length unavailable for lifecycle logging")
+            return None
+
+    @staticmethod
+    def _read_lifecycle_count(values):
+        """Read an optional count without consuming iterable strategy input."""
+        try:
+            return len(values)
+        except Exception:
+            return None
+
+    # Initialize count
+    def _init_stcount(self):
+        self.stcount = itertools.count(0)
+
+    # Call next count
+    def _next_stid(self):
+        return next(self.stcount)
+
+    def _prepare_run(self, predata=False):
+        """Start components and (optionally) preload data before strategies run.
+
+        Extracted from runstrategies() to keep that method readable. Starts
+        stores, applies cheat-on-open/fund/order-history settings, starts the
+        broker and feeds, writes CSV writer headers, and resets/preloads each
+        data feed unless ``predata`` is True.
+        """
+        # Iterate stores and start
+        for store in self.stores:
+            store.start()
+        # If cheat_on_open and broker_coo, set broker accordingly
+        if self.p.cheat_on_open and self.p.broker_coo:
+            # try to activate in broker
+            if hasattr(self._broker, "set_coo"):
+                self._broker.set_coo(True)
+        # If fund history is not None, need to set fund history
+        if self._fhistory is not None:
+            self._broker.set_fund_history(self._fhistory)
+        # Iterate order history
+        for orders, onotify in self._ohistory:
+            self._broker.add_order_history(orders, onotify)
+        # Broker start
+        self._broker.start()
+        # Feed start
+        for feed in self.feeds:
+            feed.start()
+        # If need to save writer data
+        if self.writers_csv:
+            # headers
+            wheaders = []
+            # Iterate data, if data csv attribute is True, get headers that need saving
+            for data in self.datas:
+                if data.csv:
+                    wheaders.extend(data.getwriterheaders())
+            # Save writer headers
+            for writer in self.runwriters:
+                if writer.p.csv:
+                    writer.addheaders(wheaders)
+
+        # If no predata, need to pre-process data, similar to run method preprocessing
+        if not predata:
+            for data in self.datas:
+                data.reset()
+                if self._exactbars < 1:  # datas can be a full length
+                    data.extend(size=self.params.lookahead)
+                data._start()
+                if self._dopreload:
+                    data.preload()
+
+    # Run strategy
+    def runstrategies(self, iterstrat, predata=False):
+        """
+        Internal method invoked by ``run``` to run a set of strategies
+        """
+        # Lifecycle diagnostics are opt-in and must not probe broker state
+        # before start()/after stop().  Some live/custom brokers deliberately
+        # reject those accessors outside their active lifecycle window.
+        log_lifecycle = _is_output_enabled_for(logging.INFO)
+        t0 = time.time() if log_lifecycle else None
+        initial_cash = None
+        self._init_stcount()
+        # Initialize running strategy as empty list
+        self.runningstrats = runstrats = []
+        # Start stores/broker/feeds, apply fund + order history, write headers
+        # and (optionally) preload data. Extracted for readability.
+        self._prepare_run(predata)
+        if log_lifecycle:
+            initial_cash = self._read_broker_lifecycle_value("getcash")
+            strategy_count = self._read_lifecycle_count(iterstrat)
+            logger.info(
+                "run starting: runonce=%s oldsync=%s strategies=%s datas=%d initial cash=%s",
+                self.p.runonce,
+                self.p.oldsync,
+                strategy_count if strategy_count is not None else "unavailable",
+                len(self.datas),
+                initial_cash if initial_cash is not None else "unavailable",
+            )
+            for data in self.datas:
+                name = getattr(data, "_name", "")
+                bars = self._read_data_lifecycle_length(data)
+                logger.info(
+                    "data loaded: name=%s bars=%s",
+                    name,
+                    bars if bars is not None else "unavailable",
+                )
+        # Loop through strategies
+        for stratcls, sargs, skwargs in iterstrat:
+            # Add data to strategy parameters
+            sargs = self.datas + list(sargs)
+            # Instantiate strategy with OwnerContext so findowner() can find Cerebro
+            try:
+                # Use OwnerContext so Strategy.__new__ can find Cerebro via findowner()
+                with OwnerContext.set_owner(self):
+                    # Use safe strategy creation to handle parameter filtering
+                    if hasattr(stratcls, "_create_strategy_safely"):
+                        strat = stratcls._create_strategy_safely(*sargs, **skwargs)
+                    else:
+                        # Fallback to direct instantiation
+                        strat = stratcls(*sargs, **skwargs)
+            except errors.StrategySkipError:
+                logger.warning("execution:122 suppressed bare")
+                continue  # do not add strategy to the mix
+            # Old data synchronization method
+            if self.p.oldsync:
+                strat._oldsync = True  # tell strategy to use old clock update
+            # Whether to save trade history data
+            if self.p.tradehistory:
+                strat.set_tradehistory()
+            # Add strategy
+            runstrats.append(strat)
+        # Get timezone info, if tz is integer, get tz at that index; otherwise use tzparse
+        tz = self.p.tz
+        if isinstance(tz, integer_types):
+            tz = self.datas[tz]._tz
+        else:
+            tz = tzparse(tz)
+        # StrategySkipError may exclude every strategy; cleanup still runs.
+        run_exception = None
+        # If runstrats is not empty list
+        if runstrats:
+            # loop separated for clarity
+            # Get default sizer
+            defaultsizer = self.sizers.get(None, (None, None, None))
+            # For each strategy
+            for idx, strat in enumerate(runstrats):
+                # If stdstats is True, add several observers
+                if self.p.stdstats:
+                    # Add observer broker
+                    strat._addobserver(False, observers.Broker)
+                    # Add observers.BuySell
+                    if self.p.oldbuysell:
+                        strat._addobserver(True, observers.BuySell)
+                    else:
+                        strat._addobserver(True, observers.BuySell, barplot=True)
+                    # Add observer trade
+                    if self.p.oldtrades or len(self.datas) == 1:
+                        strat._addobserver(False, observers.Trades)
+                    else:
+                        strat._addobserver(False, observers.DataTrades)
+                # Add observers and their parameters to strategy
+                for multi, obscls, obsargs, obskwargs in self.observers:
+                    strat._addobserver(multi, obscls, *obsargs, **obskwargs)
+                # Add indicators to strategy
+                for indcls, indargs, indkwargs in self.indicators:
+                    strat._addindicator(indcls, *indargs, **indkwargs)
+                # Add analyzers to strategy
+                for ancls, anargs, ankwargs in self.analyzers:
+                    strat._addanalyzer(ancls, *anargs, **ankwargs)
+                # Get specific sizer, if sizer is not None, add to strategy
+                sizer, sargs, skwargs = self.sizers.get(idx, defaultsizer)
+                if sizer is not None:
+                    strat._addsizer(sizer, *sargs, **skwargs)
+                # Set timezone
+                strat._settz(tz)
+                # Strategy start
+                strat._start()
+                # For running writers, if csv parameter is True, save strategy data to writer
+                for writer in self.runwriters:
+                    if writer.p.csv:
+                        writer.addheaders(strat.getwriterheaders())
+            # If predata is False, data not preloaded
+            if not predata:
+                # Loop each strategy, call qbuffer to cache data
+                for strat in runstrats:
+                    strat.qbuffer(self._exactbars, replaying=self._doreplay)
+            # Loop each writer, start writer
+            for writer in self.runwriters:
+                writer.start()
+
+            # Prepare timers
+            self._timers = []
+            self._timerscheat = []
+            # Loop timers
+            for timer in self._pretimers:
+                # preprocess tzdata if needed
+                # Start timer
+                timer.start(self.datas[0])
+                # If timer parameter cheat is True, add timer to self._timerscheat, otherwise add to self._timers
+                if timer.params.cheat:
+                    self._timerscheat.append(timer)
+                else:
+                    self._timers.append(timer)
+            # Run the main loop; keep cleanup deterministic, but never turn a
+            # strategy/runtime exception into a successful empty backtest.
+            try:
+                # If _dopreload and _dorunonce are True
+                if self._dopreload and self._dorunonce:
+                    # If old data alignment and sync method, use _runonce_old, otherwise use _runonce
+                    if self.p.oldsync:
+                        self._runonce_old(runstrats)
+                    else:
+                        self._runonce(runstrats)
+                # If _dopreload and _dorunonce are not both True
+                else:
+                    # If old data alignment and sync method, use _runnext_old, otherwise use _runnext
+                    if self.p.oldsync:
+                        self._runnext_old(runstrats)
+                    else:
+                        self._runnext(runstrats)
+            except Exception as exc:
+                run_exception = exc
+                logger.exception("Unhandled exception in run loop, cleaning up before re-raising")
+            finally:
+                # Iterate strategies and stop running (always runs)
+                for strat in runstrats:
+                    strat._stop()
+        # Capture the final value while the broker is still active.  This is
+        # only diagnostic data, so a custom broker may decline the accessor.
+        final_value = None
+        final_bars = None
+        if run_exception is None and log_lifecycle:
+            final_value = self._read_broker_lifecycle_value("getvalue")
+            final_bars = self._read_data_lifecycle_length(self.datas[0]) if self.datas else 0
+
+        # Stop broker
+        self._broker.stop()
+        # If predata is False, iterate data and stop each data
+        if not predata:
+            for data in self.datas:
+                data.stop()
+        # Iterate each feed and stop feed
+        for feed in self.feeds:
+            feed.stop()
+        # Iterate each store and stop store
+        for store in self.stores:
+            if getattr(store, "_cerebro_managed_lifecycle", True) is False:
+                continue
+            store.stop()
+        # Stop writer
+        self.stop_writers(runstrats)
+        if run_exception is None and log_lifecycle:
+            if final_value is None or initial_cash is None:
+                pnl = "unavailable"
+            else:
+                try:
+                    pnl = final_value - initial_cash
+                except Exception:
+                    logger.warning("broker pnl unavailable for lifecycle logging")
+                    pnl = "unavailable"
+            logger.info(
+                "run finished: final value=%s pnl=%s bars=%d elapsed=%.2fs",
+                final_value if final_value is not None else "unavailable",
+                pnl,
+                final_bars if final_bars is not None else 0,
+                time.time() - t0,
+            )
+        if run_exception is not None:
+            raise run_exception
+        # If doing parameter optimization and optreturn is True, build lightweight
+        # OptReturn results (detached from data) instead of full strategy objects.
+        if self._dooptimize and self.p.optreturn:
+            return self._build_optreturn_results(runstrats)
+
+        return runstrats
+
+    # Stop writer
+    def stop_writers(self, runstrats):
+        """Stop all writers and write final information.
+
+        Args:
+            runstrats: List of strategy instances that were run.
+
+        Collects information from data feeds and strategies, writes
+        the information to all registered writers, and stops them.
+        """
+        # Cerebro info
+        cerebroinfo = OrderedDict()
+        # Data info
+        datainfos = OrderedDict()
+        # Get info for each data, save to datainfos, then save to cerebroinfo
+        for i, data in enumerate(self.datas):
+            datainfos["Data%d" % i] = data.getwriterinfo()
+
+        cerebroinfo["Datas"] = datainfos
+        # Get strategy info and save to stratinfos and cerebroinfo
+        stratinfos = {}
+        for strat in runstrats:
+            stname = strat.__class__.__name__
+            stratinfos[stname] = strat.getwriterinfo()
+
+        cerebroinfo["Strategies"] = stratinfos
+        # Write cerebroinfo to file
+        for writer in self.runwriters:
+            writer.writedict({"Cerebro": cerebroinfo})
+            writer.stop()
+
+    # Run writer's next
+    def _next_writers(self, runstrats):
+        if not self.runwriters:
+            return
+
+        if self.writers_csv:
+            wvalues = []
+            for data in self.datas:
+                if data.csv:
+                    wvalues.extend(data.getwritervalues())
+
+            for strat in runstrats:
+                wvalues.extend(strat.getwritervalues())
+
+            for writer in self.runwriters:
+                if writer.p.csv:
+                    writer.addvalues(wvalues)
+
+                    writer.next()
+
+    # Disable runonce
+    def _disable_runonce(self):
+        """API for lineiterators to disable runonce (see HeikinAshi)"""
+        self._dorunonce = False

backtrader/_cerebro/lifecycle.py

@@ -0,0 +1,143 @@
+"""Cerebro run-scope lifecycle mixin (iteration 28 split).
+
+Moved verbatim from ``backtrader/cerebro.py``: run scope begin/end,
+external channel scope retention and runstop publication.
+"""
+
+# pylint: disable=no-member
+# Mixin state (``_run_scope_token`` etc.) is created by ``Cerebro.__init__``
+# on the assembled class; it cannot be seen from this partial class alone.
+import threading
+
+from ..utils.log_message import get_logger
+
+logger = get_logger(__name__)
+
+
+class RunLifecycleMixin:
+    """Run-scope lifecycle half of Cerebro (see module docstring)."""
+
+    def _begin_run(self):
+        """Start one synchronized run-stop scope for this Cerebro instance."""
+        with self._runstop_lock:
+            if self._run_active:
+                raise RuntimeError("Cerebro is already running")
+            self._event_stop.clear()
+            self._run_scope_token += 1
+            self._run_scope_owner = threading.get_ident()
+            self._run_active = True
+            return self._run_scope_token
+
+    def _open_run_scope(self):
+        """Open a run scope and roll it back if an overridden start hook fails."""
+        with self._runstop_lock:
+            previous_token = self._run_scope_token
+
+        try:
+            self._begin_run()
+            with self._runstop_lock:
+                if not self._run_active or self._run_scope_owner != threading.get_ident():
+                    raise RuntimeError("Cerebro run scope was not published by the calling thread")
+                return self._run_scope_token
+        except BaseException:
+            # A subclass can call ``super()._begin_run()`` and then fail. Only
+            # retire a scope created by this thread after the snapshot; never
+            # clear another thread's active run after a rejected re-entry.
+            logger.error("lifecycle:41 exception before re-raise (BaseException)", exc_info=True)
+            self._end_run_if_started_by_current_thread(previous_token)
+            raise
+
+    def _end_run_if_started_by_current_thread(self, previous_token):
+        """Undo a partially opened scope without touching a different active run."""
+        with self._runstop_lock:
+            if (
+                self._run_active
+                and self._run_scope_owner == threading.get_ident()
+                and self._run_scope_token != previous_token
+            ):
+                self._retire_run_scope_locked()
+
+    def _retire_run_scope_locked(self):
+        """Clear one active run scope while ``_runstop_lock`` is held."""
+        self._run_active = False
+        self._run_scope_owner = None
+        self._event_stop.clear()
+        self._external_channel_token = None
+        self._external_channel_runstrats = None
+        self._external_channel_closing = False
+
+    def _end_run(self, token):
+        """Retire only this caller's run-stop scope.
+
+        A timer that fires after another run has already opened remains an
+        ordinary stop request for that later active scope; callers must cancel
+        or generation-bind such timers before reusing the instance.
+        """
+        with self._runstop_lock:
+            if (
+                not self._run_active
+                or self._run_scope_owner != threading.get_ident()
+                or self._run_scope_token != token
+            ):
+                return
+            self._retire_run_scope_locked()
+
+    def _retain_external_channel_scope(self, token, runstrats):
+        """Keep a ``run(channel=True)`` session active until its owner closes it."""
+        with self._runstop_lock:
+            if (
+                not self._run_active
+                or self._run_scope_owner != threading.get_ident()
+                or self._run_scope_token != token
+            ):
+                raise RuntimeError("Cerebro external channel scope was not published by its owner")
+            self._external_channel_token = token
+            self._external_channel_runstrats = runstrats
+            self._external_channel_closing = False
+
+    def close_channel(self):
+        """Tear down an external ``run(channel=True)`` session on its owner thread.
+
+        ``runstop()`` only publishes a stop request.  The thread which called
+        ``run(channel=True)`` must call this method after its external driver
+        has stopped dispatching callbacks.  This keeps broker and strategy
+        teardown out of foreign Timer or worker threads.
+
+        Returns:
+            ``True`` if an external channel session was closed, otherwise
+            ``False`` when no such session is active.
+
+        Raises:
+            RuntimeError: If a different thread tries to close the active
+                external channel session.
+        """
+        with self._runstop_lock:
+            token = self._external_channel_token
+            if token is None or not self._run_active or self._run_scope_token != token:
+                return False
+            if self._run_scope_owner != threading.get_ident():
+                raise RuntimeError("Cerebro external channel must be closed by its owner thread")
+            if self._external_channel_closing:
+                return False
+
+            self._external_channel_closing = True
+            self._event_stop.set()
+            runstrats = self._external_channel_runstrats
+
+        try:
+            self._teardown_channel(runstrats)
+        finally:
+            self._end_run(token)
+        return True
+
+    # When called from within a strategy or elsewhere, stops execution quickly
+    def runstop(self):
+        """Request prompt termination of the currently active run.
+
+        Calls from a strategy or another thread are safe.  Calls made while
+        no ``run`` / optimization worker is active are ignored so a delayed
+        ``threading.Timer`` cannot stop a later, unrelated run.
+        """
+        with self._runstop_lock:
+            if self._run_active:
+                self._event_stop.set()

backtrader/_cerebro/notifications.py

@@ -0,0 +1,150 @@
+"""Cerebro notification dispatch mixin (iteration 28 split).
+
+Moved verbatim from ``backtrader/cerebro.py``: store/data callbacks and
+broker notification delivery.
+"""
+
+from ..brokers import BackBroker
+from ..feed import AbstractDataBase
+
+
+class NotificationMixin:
+    """Notification dispatch half of Cerebro (see module docstring)."""
+
+    def addstorecb(self, callback):
+        """Adds a callback to get messages which would be handled by the
+        notify_store method
+
+        The signature of the callback must support the following:
+
+          - callback(msg, *args, *kwargs)
+
+        The actual ``msg``, ``*args`` and ``**kwargs`` received are
+        implementation defined (depend entirely on the *data/broker/store*) but
+        in general one should expect them to be *printable* to allow for
+        reception and experimentation.
+        """
+        self.storecbs.append(callback)
+
+    def _notify_store(self, msg, *args, **kwargs):
+        """Internal method to dispatch store notifications."""
+        for callback in self.storecbs:
+            callback(msg, *args, **kwargs)
+
+        self.notify_store(msg, *args, **kwargs)
+
+    def notify_store(self, msg, *args, **kwargs):
+        """Receive store notifications in cerebro
+
+        This method can be overridden in ``Cerebro`` subclasses
+
+        The actual ``msg``, ``*args`` and ``**kwargs`` received are
+        implementation defined (depend entirely on the *data/broker/store*) but
+        in general one should expect them to be *printable* to allow for
+        reception and experimentation.
+        """
+
+    def _storenotify(self):
+        """Process and dispatch store notifications to strategies."""
+        for store in self.stores:
+            for notif in store.get_notifications():
+                msg, args, kwargs = notif
+
+                self._notify_store(msg, *args, **kwargs)
+                for strat in self.runningstrats:
+                    strat.notify_store(msg, *args, **kwargs)
+                    if hasattr(strat, "_notify_store_to_observers"):
+                        strat._notify_store_to_observers(msg, *args, **kwargs)
+
+    def adddatacb(self, callback):
+        """Adds a callback to get messages which would be handled by the
+        notify_data method
+
+        The signature of the callback must support the following:
+
+          - callback(data, status, *args, *kwargs)
+
+        The actual ``*args`` and ``**kwargs`` received are implementation
+        defined (depend entirely on the *data/broker/store*), but in general one
+        should expect them to be *printable* to allow for reception and
+        experimentation.
+        """
+        self.datacbs.append(callback)
+
+    def _datanotify(self):
+        """Process and dispatch data notifications to strategies."""
+        for data in self.datas:
+            if type(data).get_notifications is AbstractDataBase.get_notifications:
+                notifications = data.notifs
+                if not notifications:
+                    continue
+
+                notifications.append(None)
+                while True:
+                    notif = notifications.popleft()
+                    if notif is None:
+                        break
+                    status, args, kwargs = notif
+                    self._notify_data(data, status, *args, **kwargs)
+                    for strat in self.runningstrats:
+                        strat.notify_data(data, status, *args, **kwargs)
+                        if hasattr(strat, "_notify_data_to_observers"):
+                            strat._notify_data_to_observers(data, status, *args, **kwargs)
+            else:
+                for notif in data.get_notifications():
+                    status, args, kwargs = notif
+                    self._notify_data(data, status, *args, **kwargs)
+                    for strat in self.runningstrats:
+                        strat.notify_data(data, status, *args, **kwargs)
+                        if hasattr(strat, "_notify_data_to_observers"):
+                            strat._notify_data_to_observers(data, status, *args, **kwargs)
+
+    def _notify_data(self, data, status, *args, **kwargs):
+        """Internal method to dispatch data notifications."""
+        for callback in self.datacbs:
+            callback(data, status, *args, **kwargs)
+
+        self.notify_data(data, status, *args, **kwargs)
+
+    def notify_data(self, data, status, *args, **kwargs):
+        """Receive data notifications in cerebro
+
+        This method can be overridden in ``Cerebro`` subclasses
+
+        The actual ``*args`` and ``**kwargs`` received are
+        implementation defined (depend entirely on the *data/broker/store*), but
+        in general one should expect them to be *printable* to allow for
+        reception and experimentation.
+        """
+
+    # Notify broker info
+    def _brokernotify(self):
+        """
+        Internal method which kicks the broker and delivers any broker
+        notification to the strategy
+        """
+        # Call broker's next
+        broker = self._broker
+        broker.next()
+        if type(broker).get_notification is BackBroker.get_notification:
+            notifications = broker.notifs
+            while notifications:
+                order = notifications.popleft()
+                owner = order.owner
+                if owner is None:
+                    owner = self.runningstrats[0]  # default
+                # Notify order info through first strategy
+                owner._addnotification(order, quicknotify=self.p.quicknotify)
+        else:
+            while True:
+                # Get order info to notify, if order is None break loop, otherwise get order's owner.
+                # If owner is None, default to first strategy
+                order = broker.get_notification()
+                if order is None:
+                    break
+
+                owner = order.owner
+                if owner is None:
+                    owner = self.runningstrats[0]  # default
+                # Notify order info through first strategy
+                owner._addnotification(order, quicknotify=self.p.quicknotify)