@backtrader Thanks! I knew I was forgetting something. Will give it a go.

Hello All,
Can someone help shed some light on a little issue I have? I think I am missing a platform fundamental / concept

Below is a simple example code that demonstrates my issue.

Basically I am trying to create a data feed that is calculated at init and compares the current value of a data feed with the previous value before deciding what to assign to another data.

I seem to be able to get away with it when looking at data.close but not with a data feed created during init self.data.hlc3

class TestInd(bt.Indicator):

    lines = ('sig',)

    def __init__(self):
        self.addminperiod(55)
        
        self.data.hlc3 = (self.data.high + self.data.low + self.data.close) / 3
        # This works
        self.data.vd = bt.If(self.data.close[0] >= self.data.close[-1], self.data.volume, -self.data.volume)
        # This does not
        self.data.sd = bt.If(self.data.hlc3[0] >= self.data.hlc3[-1], self.data.volume, -self.data.volume)

        self.lines.sig = bt.indicators.EMA(self.data.vd, period=34) - bt.indicators.EMA(self.data.vd, period=55)

If someone could jog my memory and remind me what I am doing wrong, that would be great.

If you installed via pip, my guess is that you probably don't have direct access to it from your working directory. I.e the directory where you are trying to copy run the example script from.

If you cannot find it on your mac, try going to the github page to take a copy and place it somewhere your script can find it:

Data Folder

Hi @wysest

You can do it like this:

print(self.myindicator[0])

This will give you the most recent value. Use [-1] for the second most recent and so on. (This is a little different to python lists where [-1] will give you the last item. I think there is a note on this in the docs

[Removed ] I think I am better to investigate further before commenting more.

Hi @Ed-Bartosh
Sorry for 1 million + 1 messages.... Just want to write some things down whilst they are on my mind.

We need some way of tracking whether orders have been filled or not. This is crucial for correctly setting the position status and for using stop / limit orders.

My code above for tracking position status, does not work well for stop / limit orders. It only works for market orders. This is because it updates the position immediately after submitting the order. This issue is that a stop loss may not be filled for a few bars after submission so setting the position size here for stop/limit orders is incorrect.

Since we are not streaming data, I think the only solution is to submit a rest call every bar to check if any open orders are filled. From my testing, it seems the broker supports the next() method. So one solution would be to use this for checking if open orders have been filled and then updating the position dictionary from that.

I saw that there is a 'fetchClosedOrders' method in CCXT. Maybe we can consider making a call to that and comparing it with a list of orders that are open. We can do this by appending an orders list every time we submit an order.

Can you think of any other ways?

@thatblokedave said in Anyone use backtrader to do live trading on Bitcoin exchange?:

The _submit() method in ccxtbroker passes the params keyword argument to the ccxt. This is great because it appears the API is not unified for stop losses. As such, they need to be created using the parameters dict to specify certain exchange specific stuff.

Further testing reveals this is not a good workaround. Sometimes we don't specify params in the order and therefore it raises a KeyError.

Therefore, I think we need an extra line to extract the params if the exist in the order. There is probably a much more elegant way to do this....

def _submit(self, owner, data, exectype, side, amount, price, params):
        order_type = self.order_types.get(exectype) if exectype else 'market'
        # Extract CCXT specific params if passed to the order
        params = params['params'] if 'params' in params else params
        _order = self.store.create_order(symbol=data.symbol, order_type=order_type, side=side,
                                         amount=amount, price=price, params=params)
        order = CCXTOrder(owner, data, _order)
        pos = self.getposition(data, clone=False)
        pos.update(order.size, order.price)

        self.notify(order)
        return order

Hi @Ed-Bartosh

Since issues are disabled on the fork, I will continue to discuss new things not raised in the last commit here.

Is Backtraders self.cancel() method working for you? I was getting a TypeError

    return self.store.cancel_order(order['id'])
TypeError: 'CCXTOrder' object is not subscriptable

The problem for me was the id property is inside a ccxt_order dict within the CCXTOrder object

A change to return self.store.cancel_order(order.ccxt_order['id']) fixed it for me.

One more thing:

The _submit() method in ccxtbroker passes the params keyword argument to the ccxt. This is great because it appears the API is not unified for stop losses. As such, they need to be created using the parameters dict to specify certain exchange specific stuff.

However, I noticed that that the params dict passed to _submit contains some backtrader specific parameters such as parent and transmit. So if I specify a params dict during order creation in a strategy like so:

self.longstop = self.sell(size=1, exectype=bt.Order.Stop, params={"stopPx":8500})

The result is that the params are nested inside the dict. This raised an error on the bitmex API because it could not find my parameters.

Params: {'parent': None, 'transmit': True, 'params': {'stopPx': 8500}}

My proposal is to change to the following (without the print calls of course):

def _submit(self, owner, data, exectype, side, amount, price, params):
        order_type = self.order_types.get(exectype) if exectype else 'market'

        print("Order_type: {}".format(order_type))
        print("Params: {}".format(params))
        _order = self.store.create_order(symbol=data.symbol, order_type=order_type, side=side,
                                         amount=amount, price=price, params=params['params'])
        order = CCXTOrder(owner, data, _order)
        pos = self.getposition(data, clone=False)
        pos.update(order.size, order.price)

        self.notify(order)
        return order

I will create another pull request for this later.

@Ed-Bartosh

Ok - Will do.

I found a solution to the getposition issue. First I copied the Oanda implementation has a positions dictionary that is updated as orders are filled.

def getposition(self, data, clone=True):
        # return self.o.getposition(data._dataname, clone=clone)
        pos = self.positions[data._dataname]
        if clone:
            pos = pos.clone()

        return pos

Then it was just a case of updating the position when we submit the order

    def _submit(self, owner, data, exectype, side, amount, price, params):
        order_type = self.order_types.get(exectype) if exectype else 'market'
        _order = self.store.create_order(symbol=data.symbol, order_type=order_type, side=side,
                                         amount=amount, price=price, params=params)
        order = CCXTOrder(owner, data, _order)

        pos = self.getposition(data, clone=False)
        pos.update(order.size, order.price)

        self.notify(order)
        return order

This allowed me to properly track the position size and thus use the self.close() method.

I will include this in the pull request too.