#!/usr/bin/env python
"""Cerebro - The main engine of the Backtrader framework.
This module contains the Cerebro class, which is the central orchestrator for
backtesting and live trading operations. Cerebro manages data feeds, strategies,
brokers, analyzers, observers, and all other components of the trading system.
Key Features:
- Data feed management and synchronization
- Strategy instantiation and execution
- Broker integration for order execution
- Multi-core optimization support
- Live trading and backtesting modes
- Plotting and analysis capabilities
Example:
Basic backtest setup::
import backtrader as bt
cerebro = bt.Cerebro()
data = bt.feeds.GenericCSVData(dataname='data.csv')
cerebro.adddata(data)
cerebro.addstrategy(MyStrategy)
cerebro.broker.setcash(100000)
results = cerebro.run()
cerebro.plot()
Classes:
OptReturn: Lightweight result object for optimization runs.
Cerebro: Main backtesting/trading engine.
"""
# pylint: disable=unused-import
# ruff: noqa: F401
# NOTE (iteration 28): the module-level imports below are intentionally kept
# even where the facade no longer references every name: ``backtrader.cerebro``
# defines no ``__all__`` and ``from backtrader.cerebro import *`` has always
# exported these bindings. Narrowing them would be a breaking change
# (AC28-03 star-export parity).
import collections
import datetime
import functools
import itertools
import multiprocessing
import threading
from datetime import timezone
from typing import Dict
from . import errors, feeds, indicator, linebuffer, observers
# Iteration 28: implementation mixins (imported under private aliases so the
# star-export namespace of ``backtrader.cerebro`` stays unchanged).
from ._cerebro.channel import ChannelMixin as _ChannelMixin
from ._cerebro.execution import ExecutionMixin as _ExecutionMixin
from ._cerebro.lifecycle import RunLifecycleMixin as _RunLifecycleMixin
from ._cerebro.notifications import NotificationMixin as _NotificationMixin
from ._cerebro.presentation import PresentationMixin as _PresentationMixin
from ._cerebro.registry import RegistryMixin as _RegistryMixin
from ._cerebro.runnext import RunNextMixin as _RunNextMixin
from ._cerebro.runonce import RunOnceMixin as _RunOnceMixin
from .brokers import BackBroker
from .channel import ChannelDataRef
from .dataseries import TimeFrame
from .feed import AbstractDataBase
from .metabase import OwnerContext
from .parameters import ParameterDescriptor, ParameterizedBase
from .strategy import SignalStrategy, Strategy
from .timer import Timer
from .tradingcal import PandasMarketCalendar, TradingCalendarBase
from .utils import OrderedDict, date2num, tzparse
from .utils.dateintern import _num2date_cached
from .utils.log_message import (
_get_logging_config_snapshot,
_restore_logging_config,
get_logger,
)
from .utils.py3 import integer_types, map, range, string_types, zip
from .writer import WriterFile
logger = get_logger(__name__)
# Python 3 always provides collections.abc (the only supported baseline).
collectionsAbc = collections.abc # collections.Iterable -> collections.abc.Iterable
# Python 3.11+ has datetime.UTC, earlier versions use timezone.utc
UTC = timezone.utc
class _RunStopEvent(threading.Event):
"""A thread-safe stop signal that preserves the legacy bool checks."""
def __bool__(self):
return self.is_set()
def _runstop_scoped(run_method):
"""Publish an active run before its body and retire synchronous runs."""
@functools.wraps(run_method)
def _wrapped(self, *args, **kwargs):
token = self._open_run_scope()
retain_external_channel_scope = False
try:
result = run_method(self, *args, **kwargs)
if kwargs.get("channel") is True:
self._retain_external_channel_scope(token, result)
retain_external_channel_scope = True
return result
finally:
if not retain_external_channel_scope:
self._end_run(token)
return _wrapped
[docs]
class OptReturn:
"""Lightweight result container for optimization runs.
This class is defined at module level to make it picklable for
multiprocessing. It stores only essential information from strategy
runs during optimization to reduce memory usage.
Attributes:
p: Alias for params.
params: Strategy parameters used in this optimization run.
analyzers: Analyzer results (if returned during optimization).
Note:
Additional attributes may be set dynamically via kwargs.
"""
[docs]
def __init__(self, params, **kwargs):
"""Initialize the OptReturn object.
Args:
params: Strategy parameters used in this optimization run.
**kwargs: Additional keyword arguments to set as attributes.
"""
self.p = self.params = params
for k, v in kwargs.items():
setattr(self, k, v)
# pylint: disable=too-many-ancestors
# The eight implementation mixins keep the single public Cerebro class under
# the 900-line file budget (iteration 28); see backtrader/_cerebro/.
[docs]
class Cerebro(
_RegistryMixin,
_NotificationMixin,
_RunLifecycleMixin,
_ChannelMixin,
_ExecutionMixin,
_RunNextMixin,
_RunOnceMixin,
_PresentationMixin,
ParameterizedBase,
):
"""Params:
- ``preload`` (default: ``True``)
Whether to preload the different ``data feeds`` passed to cerebro for
the Strategies
Note: When True (default), data is loaded into memory before backtesting,
which uses more memory but significantly improves execution speed.
- ``runonce`` (default: ``True``)
Run `Indicators` in vectorized mode to speed up the entire system.
Strategies and Observers will always be run on an event-based basis
Note: When True, indicators are calculated using vectorized operations
for better performance. Strategies and observers still run event-by-event.
- ``live`` (default: ``False``)
If no data has reported itself as *live* (via the data's ``islive``
method but the end user still wants to run in ``live`` mode, this
parameter can be set to true
This will simultaneously deactivate ``preload`` and ``runonce``. It
will have no effect on memory saving schemes.
Note: Setting to True forces live mode behavior, disabling preload and
runonce optimizations, which slows down backtesting.
- ``maxcpus`` (default: None -> all available cores)
How many cores to use simultaneously for optimization
Note: Set to number of CPU cores minus 1 to avoid system overload.
Use None (default) to use all available cores.
- ``stdstats`` (default: ``True``)
If True, default Observers will be added: Broker (Cash and Value),
Trades and BuySell
Note: These observers are used for plotting. Set to False if not needed.
- ``oldbuysell`` (default: ``False``)
If ``stdstats`` is ``True`` and observers are getting automatically
added, this switch controls the main behavior of the ``BuySell``
observer
- ``False``: use the modern behavior in which the buy / sell signals
are plotted below / above the low / high prices respectively to avoid
cluttering the plot
- ``True``: use the deprecated behavior in which the buy / sell signals
are plotted where the average price of the order executions for the
given moment in time is. This will, of course, be on top of an OHLC bar
or on a Line on Cloe bar, difficult the recognition of the plot.
Note: False (modern) plots signals outside the price bars for clarity.
True (old) plots signals at execution price, overlapping with bars.
- ``oldtrades`` (default: ``False``)
If ``stdstats`` is ``True`` and observers are getting automatically
added, this switch controls the main behavior of the ``Trades``
observer
- ``False``: use the modern behavior in which trades for all datas are
plotted with different markers
- ``True``: use the old Trades observer which plots the trades with the
same markers, differentiating only if they are positive or negative
Note: False uses different markers for different trades.
True uses same markers, only distinguishing positive/negative.
- ``exactbars`` (default: ``False``)
With the default value, each and every value stored in a line is kept in
memory
Possible values:
- ``True`` or ``1``: all "lines" objects reduce memory usage to the
automatically calculated minimum period.
If a Simple Moving Average has a period of 30, the underlying data
will have always a running buffer of 30 bars to allow the
calculation of the Simple Moving Average
- This setting will deactivate ``preload`` and ``runonce``
- Using this setting also deactivates **plotting**
- ``-1``: datafeeds and indicators/operations at strategy level will
keep all data in memory.
For example: a ``RSI`` internally uses the indicator ``UpDay`` to
make calculations. This subindicator will not keep all data in
memory
- This allows keeping ``plotting`` and ``preloading`` active.
- ``runonce`` will be deactivated
- ``-2``: data feeds and indicators kept as attributes of the
strategy will keep all points in memory.
For example: a ``RSI`` internally uses the indicator ``UpDay`` to
make calculations. This subindicator will not keep all data in
memory
If in the ``__init__`` something like
``a = self.data.close - self.data.high`` is defined, then ``a``
will not keep all data in memory
- This allows keeping ``plotting`` and ``preloading`` active.
- ``runonce`` will be deactivated
Note on exactbars values:
- True/1: Minimum memory, disables preload/runonce/plotting
- -1: Keeps data/indicators but not sub-indicator internals, disables runonce
- -2: Keeps strategy-level data/indicators, sub-indicators not using self are discarded
- ``objcache`` (default: ``False``)
Experimental option to implement a cache of lines objects and reduce
the amount of them. Example from UltimateOscillator:
bp = self.data.close - TrueLow(self.data)
tr = TrueRange(self.data) # -> creates another TrueLow(self.data)
If this is `True`, the second ``TrueLow(self.data)`` inside ``TrueRange``
matches the signature of the one in the ``bp`` calculation. It will be
reused.
Corner cases may happen in which this drives a line object off its
minimum period and breaks things, and it is therefore disabled.
Note: When True, identical indicator calculations are cached and reused
to reduce computation. Disabled by default due to edge cases.
- ``writer`` (default: ``False``)
If set to ``True`` a default WriterFile will be created which will
print to stdout. It will be added to the strategy (in addition to any
other writers added by the user code)
Note: Outputs trading information to stdout. Custom logging in strategy
is usually preferred for more control.
- ``tradehistory`` (default: ``False``)
If set to ``True``, it will activate update event logging in each trade
for all strategies. This can also be achieved on a per-strategy
basis with the strategy method ``set_tradehistory``
Note: Enables trade update logging for all strategies. Can also be
enabled per-strategy using set_tradehistory method.
- ``optdatas`` (default: ``True``)
If ``True`` and optimizing (and the system can ``preload`` and use
``runonce``, data preloading will be done only once in the main process
to save time and resources.
The tests show an approximate ``20%`` speed-up moving from a sample
execution in ``83`` seconds to ``66``
Note: When True with preload/runonce, data is preloaded once in the
main process and shared across optimization workers (~20% speedup).
- ``optreturn`` (default: ``True``)
If `True`, the optimization results will not be full ``Strategy``
objects (and all *datas*, *indicators*, *observers* ...) but object
with the following attributes (same as in ``Strategy``):
- ``params`` (or ``p``) the strategy had for the execution
- ``analyzers`` the strategy has executed
On most occasions, only the *analyzers* and with which *params* are
the things needed to evaluate the performance of a strategy. If
detailed analysis of the generated values for (for example)
*indicators* is needed, turn this off
The tests show a 13% - 15% improvement in execution time. Combined
with `optdatas` the total gain increases to a total speed-up of
`32%` in an optimization run.
Note: Returns only params and analyzers during optimization, discarding
data/indicators/observers for ~15% speedup (32% combined with optdatas).
- ``oldsync`` (default: ``False``)
Starting with release 1.9.0.99, the synchronization of multiple datas
(same or different timeframes) has been changed to allow datas of
different lengths.
If the old behavior with data0 as the master of the system is wished,
set this parameter to true
Note: False allows data feeds of different lengths.
True uses data0 as master (legacy behavior).
- ``tz`` (default: ``None``)
Adds a global timezone for strategies. The argument ``tz`` can be
- ``None``: in this case the datetime displayed by strategies will be
in UTC, which has always been the standard behavior
- ``pytz`` instance. It will be used as such to convert UTC times to
the chosen timezone
- ``string``. Instantiating a ``pytz`` instance will be attempted.
- ``integer``. Use, for the strategy, the same timezone as the
corresponding ``data`` in the ``self.datas`` iterable (``0`` would
use the timezone from ``data0``)
Note: None=UTC, pytz instance converts from UTC, string creates pytz,
integer uses timezone from corresponding data feed index.
- ``cheat_on_open`` (default: ``False``)
The ``next_open`` method of strategies will be called. This happens
before ``next`` and before the broker has had a chance to evaluate
orders. The indicators have not yet been recalculated. This allows
issuing an order which takes into account the indicators of the previous
day but uses the ``open`` price for stake calculations
For cheat_on_open order execution, it is also necessary to make the
call ``cerebro.broker.set_coo(True)`` or instantiate a broker with
``BackBroker(coo=True)`` (where *coo* stands for cheat-on-open) or set
the ``broker_coo`` parameter to ``True``. Cerebro will do it
automatically unless disabled below.
Note: Enables using next bar's open price for position sizing.
Useful for precise capital allocation. Requires broker_coo=True.
- ``broker_coo`` (default: ``True``)
This will automatically invoke the ``set_coo`` method of the broker
with ``True`` to activate ``cheat_on_open`` execution. Will only do it
if ``cheat_on_open`` is also ``True``
Note: Works together with cheat_on_open parameter.
- ``quicknotify`` (default: ``False``)
Broker notifications are delivered right before the delivery of the
*next* prices. For backtesting, this has no implications, but with live
brokers, a notification can take place long before the bar is
delivered. When set to ``True`` notifications will be delivered as soon
as possible (see ``qcheck`` in live feeds)
Set to ``False`` for compatibility. May be changed to ``True``
Note: False delays notifications until next bar. True sends immediately.
Mainly relevant for live trading.
"""
# Parameter descriptors using new system
preload = ParameterDescriptor(
default=True, type_=bool, doc="Whether to preload the different data feeds"
)
runonce = ParameterDescriptor(default=True, type_=bool, doc="Run Indicators in vectorized mode")
maxcpus = ParameterDescriptor(default=None, doc="How many cores to use for optimization")
stdstats = ParameterDescriptor(default=True, type_=bool, doc="Add default Observers")
oldbuysell = ParameterDescriptor(
default=False, type_=bool, doc="Use old BuySell observer behavior"
)
oldtrades = ParameterDescriptor(
default=False, type_=bool, doc="Use old Trades observer behavior"
)
lookahead = ParameterDescriptor(default=0, type_=int, doc="Lookahead parameter")
exactbars = ParameterDescriptor(default=False, doc="Memory usage control for lines objects")
optdatas = ParameterDescriptor(
default=True, type_=bool, doc="Optimize data preloading during optimization"
)
optreturn = ParameterDescriptor(
default=True, type_=bool, doc="Return simplified objects during optimization"
)
objcache = ParameterDescriptor(
default=False, type_=bool, doc="Cache lines objects to reduce memory"
)
live = ParameterDescriptor(default=False, type_=bool, doc="Run in live mode")
writer = ParameterDescriptor(default=False, type_=bool, doc="Add a default WriterFile")
tradehistory = ParameterDescriptor(
default=False, type_=bool, doc="Activate trade history logging"
)
oldsync = ParameterDescriptor(default=False, type_=bool, doc="Use old synchronization behavior")
tz = ParameterDescriptor(default=None, doc="Global timezone for strategies")
cheat_on_open = ParameterDescriptor(
default=False, type_=bool, doc="Enable cheat-on-open execution"
)
broker_coo = ParameterDescriptor(
default=True, type_=bool, doc="Auto-activate broker cheat-on-open"
)
quicknotify = ParameterDescriptor(
default=False, type_=bool, doc="Deliver broker notifications quickly"
)
[docs]
def __init__(self, **kwargs):
"""Initialize Cerebro with optional parameter overrides.
Args:
**kwargs: Parameter overrides (preload, runonce, maxcpus, etc.)
"""
super().__init__(**kwargs)
# Internal state flags
self._timerscheat = None
self._timers = None
self.runningstrats: list = []
self.runstrats = None
self.writers_csv = None
self.runwriters = None
self._dopreload = None
self._dorunonce = None
self._exactbars = 0
# ``runstop`` may be called by a Timer or another thread while the
# engine is running. The event publishes that request safely; the
# lock defines the start/end boundary so stop requests made between
# runs cannot leak into a later run.
self._event_stop = _RunStopEvent()
self._runstop_lock = threading.RLock()
self._run_active = False
self._run_scope_token = 0
self._run_scope_owner = None
self._external_channel_token = None
self._external_channel_runstrats = None
self._external_channel_closing = False
self._dolive = False # Live trading mode flag
self._doreplay = False # Data replay mode flag
self._dooptimize = False # Optimization mode flag
# Component containers
self.stores = [] # Data stores
self.feeds = [] # Data feeds
self.datas = [] # Data objects
self.datasbyname = collections.OrderedDict() # Data lookup by name
self._channel_data_refs: Dict[str, ChannelDataRef] = {}
self.strats = [] # Strategy classes/instances
self.optcbs = [] # Optimization callbacks
self.observers = [] # Observer classes
self.analyzers = [] # Analyzer classes
self.indicators = [] # Indicator classes
self.sizers = {} # Position sizers
self.writers = [] # Output writers
self.storecbs = [] # Store callbacks
self.datacbs = [] # Data callbacks
self.signals = [] # Signal definitions
# Signal strategy configuration
self._signal_strat = (None, None, None)
self._signal_concurrent = False # Allow concurrent signals
self._signal_accumulate = False # Allow accumulating positions
# Internal counters and references
self._dataid = itertools.count(1) # Data ID counter
self._broker = BackBroker() # Default broker
self._broker.cerebro = self # Back-reference to cerebro
self._tradingcal = None # Trading calendar
self._pretimers = [] # Pre-run timers
self._ohistory = [] # Order history
self._fhistory = None # Fund history
# Override parameters from kwargs
pkeys = self.params._getkeys()
for key, val in kwargs.items():
if key in pkeys:
setattr(self.params, key, val)
[docs]
def setbroker(self, broker):
"""
Sets a specific ``broker`` instance for this strategy, replacing the
one inherited from cerebro.
"""
self._broker = broker
broker.cerebro = self
self._maybe_add_store(broker)
return broker
[docs]
def getbroker(self):
"""
Returns the broker instance.
This is also available as a ``property`` by the name ``broker``
"""
return self._broker
# Module passed to cerebro for multiprocessing during optimization
[docs]
def __call__(self, iterstrat):
"""
Used during optimization to pass the cerebro over the multiprocessing
module without complaints
"""
token = self._open_run_scope()
try:
predata = self.p.optdatas and self._dopreload and self._dorunonce
return self.runstrategies(iterstrat, predata=predata)
finally:
self._end_run(token)
# Delete runstrats when pickling
[docs]
def __getstate__(self):
"""
Used during optimization to prevent optimization result `runstrats`
from being pickled to subprocesses
"""
rv = vars(self).copy()
if "runstrats" in rv:
del rv["runstrats"]
# ``threading.Event`` and ``RLock`` are intentionally process-local.
# Optimization workers create a fresh inactive scope in ``__setstate__``.
rv.pop("_event_stop", None)
rv.pop("_runstop_lock", None)
rv["_run_active"] = False
rv["_run_scope_owner"] = None
rv.pop("_external_channel_token", None)
rv.pop("_external_channel_runstrats", None)
rv.pop("_external_channel_closing", None)
# Iteration 29: propagate only opt-in configuration, never handlers.
logging_config = _get_logging_config_snapshot()
if logging_config is not None:
rv["_logging_config"] = logging_config
else:
rv.pop("_logging_config", None)
return rv
[docs]
def __setstate__(self, state):
"""Restore process-local run-stop state after multiprocessing pickle."""
state = state.copy()
logging_config = state.pop("_logging_config", None)
self.__dict__.update(state)
self._event_stop = _RunStopEvent()
self._runstop_lock = threading.RLock()
self._run_active = False
self._run_scope_token = 0
self._run_scope_owner = None
self._external_channel_token = None
self._external_channel_runstrats = None
self._external_channel_closing = False
_restore_logging_config(logging_config)
# Core method for backtesting. Any passed kwargs affect cerebro standard parameters.
# If no data added, will stop immediately. Return value differs based on optimization.
def _resolve_run_flags(self):
"""Resolve runonce/preload/exactbars/replay/live flags and build writers.
Extracted from run() to keep that method readable. Sets the private
execution-mode flags on self and populates self.runwriters /
self.writers_csv. No behavior change.
"""
# Check if _dorunonce, _dopreload, _exactbars
self._dorunonce = self.p.runonce
self._dopreload = self.p.preload
self._exactbars = int(self.p.exactbars)
# If _exactbars is not 0, _dorunonce must be False; if _dopreload is True and _exactbars < 1, set _dopreload to True
if self._exactbars:
self._dorunonce = False # something is saving memory, no runonce
self._dopreload = self._dopreload and self._exactbars < 1
# If _doreplay is True or any data has replaying attribute True, set _doreplay to True
self._doreplay = self._doreplay or any(x.replaying for x in self.datas)
# If _doreplay, need to set _dopreload to False
if self._doreplay:
# preloading is not supported with replay. full timeframe bars
# are constructed in realtime
self._dopreload = False
# If _dolive or live, need to set _dorunonce and _dopreload to False
if self._dolive or self.p.live:
# in this case, both preload and runonce must be off
self._dorunonce = False
self._dopreload = False
# Writer list
self.runwriters = []
# Add the system default writer if requested
if self.p.writer is True:
wr = WriterFile()
self.runwriters.append(wr)
# Instantiate any other writers
for wrcls, wrargs, wrkwargs in self.writers:
wr = wrcls(*wrargs, **wrkwargs)
self.runwriters.append(wr)
# Write down if any writer wants the full csv output
self.writers_csv = any(map(lambda x: x.p.csv, self.runwriters))
[docs]
@_runstop_scoped
def run(self, **kwargs) -> list:
"""The core method to perform backtesting. Any ``kwargs`` passed to it
will affect the value of the standard parameters ``Cerebro`` was
instantiated with.
If `cerebro` has no data **and** no ``channel`` is given, the method
will immediately bail out.
Extra keyword arguments
-----------------------
channel : iterable or True, optional
When provided the engine runs in **channel mode** instead of the
traditional bar-based mode.
* *iterable* – an ``Event`` stream (``StreamingEventQueue``,
``LiveEventQueue``, or any iterable yielding ``Event``
objects). Events are dispatched to the broker and then to
every strategy via their ``notify_*`` callbacks.
* ``True`` – strategies are instantiated and returned
immediately **without** entering an event loop. This is
useful when an external async loop drives the data (e.g.
external market-data watchers calling ``strategy.notify_tick()``
directly). Call ``cerebro.close_channel()`` from the same
thread when that external loop is done to tear down brokers and
strategies.
It has different return values:
- For No Optimization: a list contanining instances of the Strategy
classes added with ``addstrategy``
- For Optimization: a list of lists which contain instances of the
Strategy classes added with ``addstrategy``
"""
# --- channel mode ---------------------------------------------------
channel = kwargs.pop("channel", None)
if channel is not None:
# _run_channel is dynamically typed; run() advertises -> list.
return self._run_channel(channel, **kwargs)
# If no data, return empty list immediately
if not self.datas:
return [] # nothing can be run
# Override standard parameters with passed kwargs
pkeys = self.params._getkeys()
for key, val in kwargs.items():
if key in pkeys:
setattr(self.params, key, val)
# Manage activate/deactivate object cache
# Manage object cache
linebuffer.LineActions.cleancache() # clean cache
indicator.Indicator.cleancache() # clean cache
linebuffer.LineActions.usecache(self.p.objcache)
indicator.Indicator.usecache(self.p.objcache)
# Resolve runonce/preload/exactbars/replay/live execution flags + writers
self._resolve_run_flags()
# Running strategy list
self.runstrats = []
# If signals is not None, handle signalstrategy related issues
if self.signals: # allow processing of signals
signalst, sargs, skwargs = self._signal_strat
if signalst is None:
# Try to see if the 1st regular strategy is a signal strategy
try:
signalst, sargs, skwargs = self.strats.pop(0)
except IndexError:
logger.debug("cerebro:715 ignored IndexError")
# Nothing there
else:
if not isinstance(signalst, SignalStrategy):
# no signal ... reinsert at the beginning
self.strats.insert(0, (signalst, sargs, skwargs))
signalst = None # flag as not present
if signalst is None: # recheck
# Still None, create a default one
signalst, sargs, skwargs = SignalStrategy, (), {}
# sargs/skwargs always come from a (args, kwargs) pair or the
# tuple()/dict() defaults above; normalize for safe unpacking.
sargs = sargs or ()
skwargs = skwargs or {}
# Add the signal strategy
self.addstrategy(
signalst,
*sargs,
_accumulate=self._signal_accumulate,
_concurrent=self._signal_concurrent,
signals=self.signals,
**skwargs,
)
# If strategy list is empty, add strategy
if not self.strats: # Datas are present, add a strategy
self.addstrategy(Strategy)
# Iterate strategies
iterstrats = itertools.product(*self.strats)
# If not optimization parameters, or using 1 cpu core
if not self._dooptimize or self.p.maxcpus == 1:
# If no optimmization is wished ... or 1 core is to be used
# let's skip process "spawning"
# Iterate through strategies
for iterstrat in iterstrats:
# Run strategy
runstrat = self.runstrategies(iterstrat)
# Add running strategy to running strategy list
self.runstrats.append(runstrat)
# If optimization parameters
if self._dooptimize:
# Iterate all optcbs to return stopped strategy results
for cb in self.optcbs:
cb(runstrat) # callback receives finished strategy
# If optimization parameters
else:
# If optdatas is True, and _dopreload, and _dorunonce
if self.p.optdatas and self._dopreload and self._dorunonce:
# Iterate each data, reset, if _exactbars < 1, extend data
# Start data
# If data _dopreload, call preload on data
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()
data.preload()
# Start process pool
pool = multiprocessing.Pool(self.p.maxcpus or None)
for r in pool.imap(self, iterstrats):
self.runstrats.append(r)
for cb in self.optcbs:
cb(r) # callback receives finished strategy
# Close process pool
pool.close()
# If optdatas is True, and _dopreload, and _dorunonce, iterate data and stop data
if self.p.optdatas and self._dopreload and self._dorunonce:
for data in self.datas:
data.stop()
# If not optimization parameters
if not self._dooptimize:
# avoid a list of list for regular cases
return self.runstrats[0]
return self.runstrats
def _build_optreturn_results(self, runstrats):
"""Build OptReturn results for an optimization run.
Detaches analyzers from their strategy/data references (so the result
is lightweight and picklable across process boundaries) and wraps each
strategy's params + analyzers in an OptReturn.
"""
results = []
for strat in runstrats:
for a in strat.analyzers:
a.strategy = None
a._parent = None
# OPTIMIZED: Use __dict__ instead of dir() for better performance
for attrname in list(a.__dict__.keys()):
if attrname.startswith("data"):
setattr(a, attrname, None)
oreturn = OptReturn(strat.params, analyzers=strat.analyzers, strategycls=type(strat))
results.append(oreturn)
return results
broker = property(getbroker, setbroker)