@Aill3urs-2019

Did you follow the article? I.e. add your api keys etc? Did you change anything e.g. tickers?

Whatever, it did output you could post here along with details of anything you changed.

@Aill3urs-2019

You might find this post useful. A template for working with Alpha Vantage

https://backtest-rookies.com/2019/01/04/backtrader-alpha-vantage-data-direct-ingest/

Hello all,
Here is a link to a datafeed which will allow you to ingest Tradingview data and signals into Backtrader. It uses a flask server to listen out for webhook alerts sent from Tradingview's. You should be able to use it to receive signals, data or both.

No backfilling though :)

https://github.com/Dave-Vallance/tv2bt

The idea is to be able to ingest TV signals and act on them with your broker of choice.

You will need to be comfortable with a bit of port forwarding to get it to work.

@backtrader Awesome. Thank you for the suggestions. I will give them a try.

Hello All,
Just wondering if anyone has experience with extending a datafeed and plotting the newly extended lines on a subplot (like an indicator)

I have some COT data coming in on the weekly and would like to plot the commercial / noncommmercial lines under the daily price chart.

I have played around trying to add an indicator that simply assigns the extended datafeed lines to the lines of the indicator. However, I am running into a couple of speed bumps...

• Because my COT data has no OHLCV values, I think I need turn plotting of the data feed off using plotinfo.plot so I avoid getting the error: ValueError Axis limits cannot be NaN or Inf.
• My guess (could be wrong) is that this now means any indicator assigned to that datafeed will not plot (because I turned plotting off - That would seem logical!).

My current thinking is to merge the weekly COT data with some dummy OHLCV data or resampled daily data so there are some values to plot and create subplots from. However, it won't look so nice on the final chart and I am wondering if anyone can think of a better way?

Or perhaps I am extending the data feed incorrectly? Here is my extended code. It works with a pandas dataframe downloaded directly from Quandl

class COT_Feed(bt.feeds.PandasData):

    # Add a 'pe' line to the inherited ones from the base class
    lines = (
        'ncl',  # Noncommercial long
        'ncs',  # Noncommercial Short
        'cl',   # Commercial Long
        'cs',   # Commercial Short
        )

    params = (
        ('open', -1),
        ('high', -1),
        ('low', -1),
        ('close', -1),
        ('volume', -1),
        ('openinterest', 0),
        ('ncl', 1),
        ('ncs', 2),
        ('cl', 4),
        ('cs', 5)
        )

The feed works in a simple strategy where I can access the values from the feed using d.ncl[0]... It is only the plotting part I am having some trouble with.

Maybe I am over thinking this and there is a simple solution?

I noticed that the when using multiple data feeds, the buy and sell markers can appear on different dates even though notify_order() reports them both being filled on the same date.

Not sure if this is a misunderstanding on my part or not....

Anyway, I created an example script to reproduce the phenomenon. The script will attempt to use order_target_percent() at fixed dates. As such, I would expect them to be filled on the same date (which they appear to be!)

import backtrader as bt
from datetime import datetime

class TestStrategy(bt.Strategy):

    def __init__(self):
        pass

    def next(self):

        for i, d in enumerate(self.datas):
            dt = d.datetime.datetime().date()
            dn = d._name
            pos = self.getposition(d).size
            #print(dt,type(dt))
            if dt == datetime(2017,6,1).date():
                print('{} Sending Order: {} | Current Pos: {}'.format(dt,dn,pos))

                if dn == 'AAPL':
                    self.order_target_percent(d, target=0.3)
                else:
                    self.order_target_percent(d, target=0.7)

            if dt == datetime(2017,9,1).date():
                print('{} Sending Order: {} | Current Pos: {}'.format(dt,dn,pos))
                if dn == 'AAPL':
                    self.order_target_percent(d, target=0.1)
                else:
                    self.order_target_percent(d, target=0.1)


    def notify_order(self, order):
        date = self.data.datetime.datetime().date()

        if order.status == order.Completed:
            print('{} >> Order Completed >> Stock: {},  Ref: {}, Size: {}, Price: {}'.format(

                                                        date,
                                                        order.data._name,
                                                        order.ref,
                                                        order.size,
                                                        'NA' if not order.price else round(order.price,5)
                                                        ))


    def notify_trade(self, trade):
        date = self.data.datetime.datetime().date()
        if trade.isclosed:
            print('{} >> Notify Trade >> Stock: {}, Close Price: {}, Profit, Gross {}, Net {}'.format(
                                                date,
                                                trade.data._name,
                                                trade.price,
                                                round(trade.pnl,2),
                                                round(trade.pnlcomm,2)))

startcash = 10000

#Create an instance of cerebro
cerebro = bt.Cerebro()

# data lists
data = bt.feeds.Quandl(
    dataname='AAPL',
    fromdate = datetime(2017,1,1),
    todate = datetime(2018,1,1),
    buffered= True
    )

data2 = bt.feeds.Quandl(
    dataname='F',
    fromdate = datetime(2017,1,1),
    todate = datetime(2018,1,1),
    buffered= True
    )

data_list = [(data, 'AAPL'), (data2, 'F')]

#Add our strategy
cerebro.addstrategy(TestStrategy)

# Create a Data Feed
for asset in data_list:

    # Add the data
    cerebro.adddata(
                asset[0],
                name=asset[1])


# Set our desired cash start
cerebro.broker.setcash(startcash)
cerebro.broker.set_checksubmit(False)

# Run over everything
cerebro.run()

cerebro.plot(style='candlestick')

This will then result in an output and chart that looks like this:

Am I being a dumbo and missing something obvious?

@sirhc

Is that the kind of problem you add and corrected when you say " speeding up backfilling" ?

Yes - That is correct. The reason it is slow is because the broker will try to check your cash/balance on every call of next(). (If I remember correctly it makes 2 or 3 checks in total between each call of next). Since, the store will make use rest API calls to do these checks, this can add quite a few seconds delay between each call of next(). (Because of the rest API rate limit).

So in my fork, I cheat a bit. The cash and balance checks return the last values received from the last rest call. They do not make another call. Instead, the user must manually check the balance if they need up to date balance information before entering a position. (at which point the latest values will be saved).

Not an ideal solution but it works for me.

@backtrader Awesome! Thanks, I will take a look

@vandan-chopra

You can load multiple strategies into cerebro as far as I am aware. However, perhaps you just need to rethink your planned architecture?

If the "mothership" will be finally responsible for buying and selling (creating the portfolio), then it sounds like you just need to generate unique signals on specific data feeds (assets).

If that is the case, you can create indicators that generate signals according to your buy and sell principles. Then just allocate those indicators to the specific asset classes you are interested in. Finally, in next(), you can look at all of the signals and decide how to build your portfolio. No need for multiple instances.

Just a suggestion.

@chuka

You can just setup a live algorithm and backfill from a file or even the live source if they have enough data for training available.