backtrader.brokers.bbroker module¶

Back Broker Module - Backtesting broker simulation.

This module provides the BackBroker for simulating broker behavior during backtesting.

Classes:: BackBroker: Broker simulator for backtesting (alias: BrokerBack).

Example

>>> cerebro = bt.Cerebro()
>>> # Uses BackBroker by default

class backtrader.brokers.bbroker.BackBroker[source]¶

Bases: BrokerBase

Broker Simulator

The simulation supports different order types, checking a submitted order cash requirements against current cash, keeping track of cash and value for each iteration of cerebro and keeping the current position on different datas.

cash is adjusted on each iteration for instruments like futures for: which a price change implies in real brokers the addition/subtraction of cash.

# This backtesting simulation class supports different order types, checks if current cash meets the cash requirements for submitted orders, # checks cash and value at each bar, and positions on different data feeds

Supported order types:

Market: to be executed with the 1st tick of the next bar (namely the open price)

Close: meant for intraday in which the order is executed with the closing price of the last bar of the session

Limit: executes if the given limit price is seen during the session

Stop: executes a Market order if the given stop price is seen

StopLimit: sets a Limit order in motion if the given stop price is seen

# Supported order types include the five basic types above. In fact, there are other order types supported. Refer to previous tutorials # https://blog.csdn.net/qq_26948675/article/details/122868368

Because the broker is instantiated by Cerebro and there should be (mostly) no reason to replace the broker, the params are not controlled by the user for the instance. To change this there are two options:

Manually create an instance of this class with the desired params and use cerebro.broker = instance to set the instance as the broker for the run execution

Use the set_xxx to set the value using cerebro.broker.set_xxx where `xxx stands for the name of the parameter to set

Note

cerebro.broker is a property supported by the getbroker and setbroker methods of Cerebro

# Normally there is no need to set broker parameters. If setting is needed, there are usually two methods: first is to create a broker instance, then cerebro.broker = instance # The second method is to use cerebro.broker.set_xxx to set different parameters

Params:

# The meanings of some parameters are below

cash (default: 10000): starting cash
# cash is the starting capital amount, default is 10000
commission (default: CommInfoBase(percabs=True)) base commission scheme which applies to all assets

# Commission class for how to charge commissions, margin, etc. for asset trading. Default is CommInfoBase(percabs=True)
checksubmit (default: True) check margin/cash before accepting an order into the system # Whether to check if margin and cash are sufficient when passing an order to the system. Default is to check
eosbar (default: False): With intraday bars consider a bar with the same time as the end of session to be the end of the session. This is not usually the case, because some bars (final auction) are produced by many exchanges for many products for a couple of minutes after the end of the session

# End-of-session bar, default is False. For intraday bars, consider a bar with the same time as the end of session as the end of day’s trading. # However, this is usually not the case, because many assets’ bars are formed through final auctions at many exchanges a few minutes after the end of the day’s trading time
filler (default: None)

A callable with signature: callable(order, price, ago)
- order: obviously the order in execution. This provides access to the data (and with it the ohlc and volume values), the execution type, remaining size (order.executed.remsize) and others.
  
  Please check the Order documentation and reference for things available inside an Order instance
- price the price at which the order is going to be executed in the ago bar
- ago: index meant to be used with order.data for the extraction of the ohlc and volume prices. In most cases this will be 0 but on a corner case for Close orders, this will be -1.
  
  In order to get the bar volume (for example) do: volume = order.data.voluume[ago]
The callable must return the executed size (a value >= 0)

The callable may of course be an object with __call__ matching the aforementioned signature

With the default None orders will be completely executed in a single shot

# filler is a callable object, default is None. In this case, all trading volume can be executed; if filler is not None, # it will calculate the executable order size based on order, price, ago # Reference articles: https://blog.csdn.net/qq_26948675/article/details/124566885?spm=1001.2014.3001.5501 # https://yunjinqi.blog.csdn.net/article/details/113445040
slip_perc (default: 0.0) Percentage in absolute terms (and positive) that should be used to slip prices up/down for buy/sell orders

Note:
- 0.01 is 1%
- 0.001 is 0.1%
# Percentage slippage form
slip_fixed (default: 0.0) Percentage in units (and positive) that should be used to slip prices up/down for buy/sell orders

Note: if slip_perc is non zero, it takes precedence over this.

# Fixed slippage form. If percentage slippage is not 0, only percentage slippage is considered
slip_open (default: False) whether to slip prices for order execution which would specifically used the opening price of the next bar. An example would be Market order which is executed with the next available tick, i.e: the opening price of the bar.

This also applies to some of the other executions, because the logic tries to detect if the opening price would match the requested price/execution type when moving to a new bar.

# Whether to use the next bar’s opening price when calculating slippage
slip_match (default: True)

If True the broker will offer a match by capping slippage at high/low prices in case they would be exceeded.

If False the broker will not match the order with the current prices and will try execution during the next iteration

# If the price with slippage exceeds the high or low price, and if slip_match is set to True, the execution price will be calculated based on the high or low price # If not set to True, it will wait for the next bar to attempt execution
slip_limit (default: True)

Limit orders, given the exact match price requested, will be matched even if slip_match is False.

This option controls that behavior.

If True, then Limit orders will be matched by capping prices to the limit / high/low prices

If False and slippage exceeds the cap, then there will be no match

# Limit orders will seek strict matching, even when slip_match is False # If slip_limit is set to True, limit orders will be executed if they are between the high and low prices # If set to False, limit orders with slippage that exceeds high and low prices will not be executed
slip_out (default: False)

Provide slippage even if the price falls outside the high - low range.

# When slip_out is set to True, slippage will be provided even if the price exceeds the high-low range
coc (default: False)

Cheat-On-Close Setting this to True with set_coc enables
matching a Market order to the closing price of the bar in which the order was issued. This is actually cheating, because the bar is closed and any order should first be matched against the prices in the next bar

# When coc is set to True, when placing a market order, it allows execution at the closing price
coo (default: False)

Cheat-On-Open Setting this to True with set_coo enables
matching a Market order to the opening price, by for example using a timer with cheat set to True, because such a timer gets executed before the broker has evaluated

# When coo is set to True, market orders are allowed to execute at the opening price, similar to tbquant mode
int2pnl (default: True)

Assign generated interest (if any) to the profit and loss of operation that reduces a position (be it long or short). There may be cases in which this is undesired, because different strategies are competing and the interest would be assigned on a non-deterministic basis to any of them. # int2pnl, default is True. TODO: Understand literally as transferring generated interest costs to pnl
shortcash (default: True)

If True then cash will be increased when a stocklike asset is shorted and the calculated value for the asset will be negative.

If False then the cash will be deducted as operation cost and the calculated value will be positive to end up with the same amount

# For stock-like assets, if this parameter is set to True, when short selling, the available cash will increase, but the asset value will be negative # If this parameter is set to False, when short selling, the available cash decreases, and the asset value is positive
fundstartval (default: 100.0)

This parameter controls the start value for measuring the performance in a fund-like way, i.e.: cash can be added and deducted increasing the amount of shares. Performance is not measured using the net asset value of the portfolio but using the value of the fund # fundstartval will calculate performance in fund mode
fundmode (default: False)

If this is set to True analyzers like TimeReturn can automatically calculate returns based on the fund value and not on the total net asset value # If fundmode is set to True, some analyzers like TimeReturn will use fund value to calculate returns

cash¶

checksubmit¶

Advanced parameter descriptor with type checking and validation.