Posts made by run-out

@trepx86 Have a look at my answer here

@bowguo If you want to change the orders as soon as the buy is complete, there's not much point in using the bracket order. You can create One cancels other orders in the notify_order when the buy is complete.

@paulchui What have you tried so far?

DUPLICATE POST https://community.backtrader.com/post/17875
@newtrader15 Please do not post the same question twice.

Please redirect to here

https://community.backtrader.com/post/17875

@hakankaan Try selling your security first. margin indicates usually that you don't have enough cash in your account, because you are buying your security before selling the other.

@bo This answer gives a rough idea of how to approach it. Create an index covering the entire period. Use pandas to reindex your data for the whole period using 0 value when the future is not trading. Load into backtrader using pandas feed.

Then filter out 0 datas in your next

@newtrader15 Can you please include all your code. Thanks

@asdasda Read up on how to create and add analyzers to backtrader. You should find you answer there.

@vypy1 Here

@asdasda This feels a bit hacky but try:

len(self.datas[0].array)

@asdasda I use plotly. You can export your analyzers (not observers) at the end of your backtest. When you call:

cerebro.run()

cerebro returns a list of strategy objects at the end of the backtest. Usually you run one backtest a time so there's only one strategy object in the list, but some people run multiple strategies at once.

In the strategy object are all the analyzers, amongst other things.

The analyzers are contained in a list so that if you go:

strat = cerebro.run()
# analyzers are found in a list here. 
strat[0].analyzers  # you find all the analyzers here.

There's a handy method to get the results of your analyzer.

strat[0].analyzers.getbyname("trade_list").get_analysis()

Analyzers have different outputs so it's really up to you to move this data to a csv/excel/db file.

Here is an example of an analyzer being converted for a database and for going to an excel sheet.

Here's an example of an analyzer and the code I use after to convert it to db and excel.

# ANALYZER: 
class CashMarket(bt.analyzers.Analyzer):
    """
    Analyzer returning cash and market values
    """

    def __init__(self):
        self.current_date = None

    def start(self):
        super(CashMarket, self).start()

    def create_analysis(self):
        self.rets = {}
        self.vals = 0.0

    def notify_cashvalue(self, cash, value):
        date = self.data.datetime.date()
        if date != self.current_date:
            self.vals = (cash, value)
            self.rets[self.strategy.datetime.datetime()] = self.vals
            self.current_date = date
        else:
            pass

    def get_analysis(self):
        return self.rets
# CONVERTING RESULTS

def cashmarket(
    scene, analyzer, test_number, workbook=None, sheet_format=None, agg_dict=None
):
    """
    Portfolio cash and total values.

    :param workbook: Excel workbook to be saved to disk.
    :param analyzer: Backtest analyzer.
    :param sheet_format: Dictionary holding formatting information such as col width, font etc.
    :param agg_dict: Collects the dictionary outputs from backtrader for using in platting.
    :return workbook: Excel workbook to be saved to disk.
    """
    # Get the stats auto ordered nested dictionary
    value = analyzer.get_analysis()

    columns = [
        "Date",
        "Cash",
        "Value",
    ]

    if scene["save_db"]:
        df = pd.DataFrame(value)
        df = df.T
        df = df.reset_index()
        df.columns = columns
        df = add_key_to_df(df, test_number)
        agg_dict["value"] = df

    if scene["save_excel"]:

        worksheet = workbook.add_worksheet("value")

        worksheet.write_row(0, 0, columns)

        worksheet.set_row(0, None, sheet_format["header_format"])

        worksheet.set_column("A:C", sheet_format["wide"], sheet_format["float_2d"])

        for i, (k, v) in enumerate(value.items()):
            date = k.strftime("%y-%m-%d %H:%M")
            worksheet.write_row(i + 1, 0, [date])
            worksheet.write_row(i + 1, 1, v)

    return workbook, agg_dict

Could you ask your question more completely. I don't really understand what you are doing so am unable to assist. Thanks.

@asdasda Create an indicator line that returns the positive values.

self.abs = bt.If(
    (self.datas[0].close - self.datas[0].open) < 0,
   -(self.datas[0].close - self.datas[0].open),
    (self.datas[0].close - self.datas[0].open),
        )

@asdasda Move print(len(self)) to next.

@rishabmah5 It would be significantly more helpful if you supplied OHLC data for each bar, if we are going to analyze OHLC to answer the question.

Maybe some of this thread helps? https://community.backtrader.com/topic/2/limit-order-with-a-day-valid-never-gets-executed-220/13

@max-kat We need more information about your data file. Can you add in the first few rows including the header row? If no header, please provide details of each column separately .

@calebsandfort Sure just input earlier data, and then in your next check the date before starting to trade. So for example, you would start your data 2015,1,1 and then in your strategy:

def __init__(self):
    self.trade_start = datetime.datetime(2016, 1, 1, 0, 0)

def next(self):
    dt = self.data.datetime.datetime()
    if dt < self.trade_start:
        return

Or enter trade_start as a parameter.

@marsario There have been a lot of conversations on this topic. Here is one I remember. https://community.backtrader.com/topic/2240/how-to-speed-up-almost-100-times-when-add-data-and-preload-data?_=1626988579575

Try a thorough search through the community, I'm sure this topic has been bantied about a lot.

@stevenm100 In order to match the dynamic indicator article, you will need to make a number of changes.

1. Change your TrailStop init to include dunders:

def __init__(self):

2. Indicator next: Modify your atr and data close to the following:

self.l.trailstop[0] = max(
    self.datas[0].close[0] - self.p.trail_mult * self.l.trailatr[0],
    self.l.trailstop[-1],
)

If you wish to add in the parameter manually, add tradeopen to your params in strategy and you can then feed this into the indicator TradeStop.

class TestStrategy(bt.Strategy):
    params = (
        ("fast_ma", 20),
        ("trail_mult", 4),
        ("tradeopen", True),
    )
...
self.TrailStop = TrailStop(
    self.datas[0], tradeopen=self.p.tradeopen
    )

To dynamically update, you can add the trade open boolean in notify_trade:

def notify_trade(self, trade):
    self.TrailStop.p.tradeopen = trade.isopen
 

Finally, I believe you need to set runonce=False when launching cerebro, This will evaluate the indicator with the strategy.

cerebro.run(runonce=False)

This seems to generate some results like you are looking for I believe.

***INDICATOR NEXT self.l.trailatr[0] = 0.10698710357525403, tradeopen param = True, at len: 214 tailstop = 146.34227850992914***
***STRAT NEXT self.TrailStop.trailstop[0] = 146.34227850992914, at len: 214***
inside indicator if statement
***INDICATOR NEXT self.l.trailatr[0] = 0.10328759976069737, tradeopen param = True, at len: 215 tailstop = 146.34227850992914***
***STRAT NEXT self.TrailStop.trailstop[0] = 146.34227850992914, at len: 215***
inside indicator if statement
***INDICATOR NEXT self.l.trailatr[0] = 0.10495835150337765, tradeopen param = True, at len: 216 tailstop = 146.34227850992914***
***STRAT NEXT self.TrailStop.trailstop[0] = 146.34227850992914, at len: 216***
******SELLING, SET PARAM FALSE*****
stop price updated = 145.93
in indicator else statement
***INDICATOR NEXT self.l.trailatr[0] = 0.10146324877491489, tradeopen param = False, at len: 217 tailstop = 0.0***
***STRAT NEXT self.TrailStop.trailstop[0] = 0.0, at len: 217***
stop price updated = 145.94
in indicator else statement
***INDICATOR NEXT self.l.trailatr[0] = 0.09918740729586091, tradeopen param = False, at len: 218 tailstop = 0.0***
***STRAT NEXT self.TrailStop.trailstop[0] = 0.0, at len: 218***
stop price updated = 145.95

The total code is here:

import backtrader.feeds as btfeed
import pandas as pd
import backtrader as bt
from pandas_datareader import data as pdr
import yfinance as yf

yf.pdr_override()


class TrailStop(bt.Indicator):
    lines = (
        "trailatr",
        "trailstop",
    )
    params = (
        ("tradeopen", False),
        ("atr_period", 10),
        ("trail_mult", 4),
    )
    plotinfo = dict(subplot=False)
    plotlines = dict(
        trailstop=dict(
            color="blue",
            ls="--",
            _plotskip=False,
        ),
        trailatr=dict(color="black", ls="-", _plotskip=False),
    )

    def __init__(self):
        self.l.trailatr = bt.indicators.AverageTrueRange(period=self.p.atr_period)

    def next(self):

        # self.p.tradeopen = True
        if (
            self.p.tradeopen
        ):  # using "if True:" this gets accessed and result is self.l.trailstop[0] = 1. suggests uim using the wrong way to access param?
            self.l.trailstop[0] = max(
                self.datas[0].close[0] - self.p.trail_mult * self.l.trailatr[0],
                self.l.trailstop[-1],
            )
            print("inside indicator if statement")

        else:
            self.l.trailstop[0] = min(0, 1)
            print("in indicator else statement")

        print(
            "***INDICATOR NEXT self.l.trailatr[0] = {}, tradeopen param = {}, at len: {} tailstop = {}***".format(
                self.l.trailatr[0],
                self.p.tradeopen,
                len(self.l.trailatr),
                self.l.trailstop[0],
            )
        )


# Create a Stratey
class TestStrategy(bt.Strategy):
    params = (
        ("fast_ma", 20),
        ("trail_mult", 4),
        ("tradeopen", True),
    )

    def log(self, txt, dt=None):
        """ Logging function fot this strategy"""
        dt = dt or self.datas[0].datetime.date(0)
        # print('%s, %s' % (dt.isoformat(), txt)) # #-out to turn logging off

    def __init__(self):
        # Keep a reference to the "close" line in the data[0] dataseries
        self.dataclose = self.datas[0].close
        atestst = self.p.tradeopen
        self.atr = bt.indicators.AverageTrueRange(
            self.datas[0]
        )  # using for manually calculating exit in strategy next
        self.stopprice = 0  # for manually working out the stop in strategy next

        self.TrailStop = TrailStop(
            self.datas[0], tradeopen=self.p.tradeopen
        )  # instantiate the
        # TrailStop Class

        # To keep track of pending orders and buy price/commission
        self.order = None
        self.buyprice = None
        self.buycomm = None

        # Add a MovingAverageSimple indicator
        self.sma = bt.indicators.ExponentialMovingAverage(
            self.datas[0].close, period=self.p.fast_ma
        )

        self.buysig = bt.indicators.AllN(self.datas[0].low > self.sma, period=3)

    def notify_order(self, order):
        if order.status in [order.Submitted, order.Accepted]:
            # Buy/Sell order submitted/accepted to/by broker - Nothing to do
            return

        # Check if an order has been completed
        # Attention: broker could reject order if not enough cash
        if order.status in [order.Completed]:
            if order.isbuy():
                self.log(
                    "BUY EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
                    % (order.executed.price, order.executed.value, order.executed.comm)
                )

                self.buyprice = order.executed.price
                self.buycomm = order.executed.comm
            else:  # Sell
                self.log(
                    "SELL EXECUTED, Price: %.2f, Cost: %.2f, Comm %.2f"
                    % (order.executed.price, order.executed.value, order.executed.comm)
                )

            # Keep track of which bar execution took place
            self.bar_executed = len(self)

        elif order.status in [order.Canceled, order.Margin, order.Rejected]:
            self.log("Order Canceled/Margin/Rejected")

        # Write down: no pending order
        self.order = None

    def notify_trade(self, trade):
        self.TrailStop.p.tradeopen = trade.isopen
        if not trade.isclosed:
            return

        self.log("OPERATION PROFIT, GROSS %.2f, NET %.2f" % (trade.pnl, trade.pnlcomm))

    def next(self):
        # Simply log the closing price of the series from the reference
        self.log("Close, %.2f" % self.dataclose[0])

        print(
            "***STRAT NEXT self.TrailStop.trailstop[0] = {}, at len: {}***".format(
                self.TrailStop.trailstop[0], len(self.datas[0])
            )
        )

        # Check if an order is pending ... if yes, we cannot send a 2nd one
        if self.order:
            return

        # Check if we are in the market
        if not self.position:

            # Not yet ... we MIGHT BUY if ...
            if self.buysig:
                # BUY, BUY, BUY!!! (with default parameters)
                self.log("BUY CREATE, %.2f" % self.dataclose[0])

                # Keep track of the created order to avoid a 2nd order
                self.order = self.buy()
                self.TrailStop.p.tradeopen = True
                print("******BUYING, SET PARAM TRUE*****")
                self.stopprice = self.data.close[0] - self.p.trail_mult * self.atr[0]
                print("stop price = {:.2f}".format(self.stopprice))

        elif self.data.close[0] < self.stopprice:
            self.close()
            self.stopprice = 0
            self.TrailStop.p.tradeopen = False
            print("******SELLING, SET PARAM FALSE*****")

        if (
            self.stopprice < self.dataclose[0] - self.p.trail_mult * self.atr[0]
        ):  # if old price < new price
            self.stopprice = (
                self.dataclose[0] - self.p.trail_mult * self.atr[0]
            )  # assign new price
            print("stop price updated = {:.2f}".format(self.stopprice))


starting_balance = 50000

if __name__ == "__main__":
    ticker_id = "AAPL"

    dataframe = pdr.get_data_yahoo(
        ticker_id,
        period="1d",
        interval="1m",
        start="2021-07-20",
        end="2021-07-21",
        prepost=False,
    )

    dataframe = dataframe[dataframe.index.strftime("%H:%M") < "20:00"]
    data = bt.feeds.PandasData(dataname=dataframe)

    # Create a cerebro entity, add strategy
    cerebro = bt.Cerebro()
    cerebro.addstrategy(TestStrategy)

    # Add the Data Feed to Cerebro, set desired cash, set desired commission
    cerebro.adddata(data)
    cerebro.broker.setcash(starting_balance)
    cerebro.broker.setcommission(commission=0.0)

    # Add a FixedSize sizer according to the stake
    cerebro.addsizer(bt.sizers.PercentSizer, percents=10)

    # Run over everything
    cerebro.run(runonce=False)
    cerebro.plot(style="candlestick")