0.2.4 -> 0.3.1-0.3.0 self.buy/sell not puting order anymore?

[Benouare]

Hi,

Before to start, just want to tell that I know that the _.strategy is not in the official documentation, i know that using it could be risky because it could change at anytime without support.

Expected Behavior

Requirements :
Backtesting==0.2.4

class Test(Strategy):
    def init(self):
        price = self.data.Close

    def next(self):
        if not self.position:
            if self.data.index[-1].date() == date(2010, 5, 13):
                print("buy")
                self.buy()

In 0.2.4, if today == 2010, 5, 13, and if my strategy is doing self.buy, I expect that my strategy will buy the stock tomorrow at the open price. But for now/today, I "just" expect, that the lib add and order in the orders list.

data = GOOG
the_date = pd.to_datetime(datetime(2010, 5, 13))
data = data.loc[:the_date]
bt = Backtest(data, Test,
                      cash=10000, commission=.002)
output = bt.run()
print(output._strategy.orders)

it will gives to me an array with one order inside. The order is not contingent (not at sl/tp) :

(<Order size=1.0, contingent=0>,)

This order will be executed tomorrow when the stockmarket will open (@ open price).

Actual Behavior

In 0.3.1, with the same data, the same strategy, the order array is empty.
I would like to know if i missunderstood something, if there is an other way to know if there is a pending buy/sell order, or if this is a bug.

Steps to Reproduce

1. pip install backtesting==0.2.4
2. pytest test.py
   That will gives you :

buy
(<Order size=1.0, contingent=0>,)
<Order size=1.0, contingent=0>

3. pip install backtesting==0.3.1
4. pytest test.py
   That will gives you :

buy
()
IndexError: tuple index out of range

---

import unittest
from datetime import date, datetime

import pandas as pd
from backtesting import Backtest, Strategy
from backtesting.test import GOOG, SMA


class Test(Strategy):
    def init(self):
        price = self.data.Close

    def next(self):
        if not self.position:
            if self.data.index[-1].date() == date(2010, 5, 13):
                print("buy")
                self.buy()


class BasicTestSuite(unittest.TestCase):
    """Basic test cases."""

    def test_lib(self):
        data = GOOG
        the_date = pd.to_datetime(datetime(2010, 5, 13))
        data = data.loc[:the_date]

        bt = Backtest(data, Test,
                      cash=10000, commission=.002)
        output = bt.run()
        print(output._strategy.orders)
        print(output._strategy.orders[0])
        self.assertEqual(len(output._strategy.orders), 1)


if __name__ == '__main__':
    unittest.main()

[kernc]

Thanks for an excellent issue report!

I know that the _.strategy is not in the official documentation, i know that using it could be risky because it could change at anytime without support.

stats._strategy is documented and thus the official interface. 🚀

This order will be executed tomorrow when the stockmarket will open (@ open price).

Indeed, this is how it works, the orders are executed on next bar's open price.
You're experiencing b4d04dc (a fix for #158) where we run one final broker iteration to handle any orders placed in the last bar.

I see, if you're relying on Backtesting to give you forward actionable signals, you don't want the dummy broker to fill those last-bar orders. Is this the case?

[Benouare]

Thx for your reply,

I see, if you're relying on Backtesting to give you forward actionable signals, you don't want the dummy broker to fill those last-bar orders. Is this the case?

Yes, i think it's exactly my use case : I want to get the signal to know if I should buy this stock or not. So yes, I dont want that the dummy broker is doing this job.

Edit : I have just tested with the 0.3.0, and it looks that there is already this behavior. So, I am not sur that the issue comes from #158 and b4d04dc

[kernc]

The change was already in 0.3.0.

I think it's simple enough to workaround:

class LastBarOrdersMixin:
    def init(self):
        self.data_len = len(self.data)
        self.last_bar_orders = []

    def buy(self, **kwargs):
        super().buy(**kwargs)
        self._maybe_log_order()

    def self(self, **kwargs):
        super().sell(**kwargs)
        self._maybe_log_order()

    def _maybe_log_order(self):
        if len(self.data) == self.data_len:
            self.last_bar_orders.append(self.orders[-1])

Used as:

class MyStrategy(LastBarOrdersMixin, Strategy):
    ...

stats = bt.run(...)
stats._strategy.last_bar_orders  # ... 

[Benouare]

Ok. This should do the trick.
It looks that the behavior changes as well for self.position.
I will use your trick to get this information too.

[Benouare]

Ok, this behavior is really disturbing in my case. For example, I would like to keep a trade that i want to consider open, when in the other hand, the same trade is already close(stats._strategy.closed_trades).
But I completely understand that it could be useful for other user/use case.

What do you think about to put a "close_all_at_end" optional param in the constructor of backtest, to make me lib able to close all the pending orders/positions/trades at the last data iteration? For me, the default behavior should be to dont close the position/orders/trades.

with something like that maybe?

class Backtest:
    def __init__(self,
                 data: pd.DataFrame,
                 strategy: Type[Strategy],
                 *,
                 cash: float = 10_000,
                 commission: float = .0,
                 margin: float = 1.,
                 trade_on_close=False,
                 hedging=False,
                 exclusive_orders=False
                 close_all_at_end=False
                 ):

and

    def run(self, **kwargs) -> pd.Series:
[...]
            for i in range(start, len(self._data)):
                # Prepare data and indicators for `next` call
                data._set_length(i + 1)
                for attr, indicator in indicator_attrs:
                    # Slice indicator on the last dimension (case of 2d indicator)
                    setattr(strategy, attr, indicator[..., :i + 1])

                # Handle orders processing and broker stuff
                try:
                    broker.next()
                except _OutOfMoneyError:
                    break

                # Next tick, a moment before bar close
                strategy.next()
            elif self.close_all_at_end is True:
                # Close any remaining open trades so they produce some stats
                for trade in broker.trades:
                    trade.close()

                # Re-run broker one last time to handle orders placed in the last strategy
                # iteration. Use the same OHLC values as in the last broker iteration.
                if start < len(self._data):
                    try_(broker.next, exception=_OutOfMoneyError)

[kernc]

Indeed, any trades that remain open are also closed (since f77786e, #183).

These behaviors make sense for a backtest.

You could identify trades that were supposed to remain open in your case by something like:

trades = stats._trades
my_open_trades = trades[trades.ExitTime == ohlc_data.index[-1]]

That, however, would include trades that were ordered to close one day prior. 🤔

[Benouare]

@kernc, I have made my "own" version without the automatic close behavior.
If you want to integrate it (or just have look at it) let me know.