Hi, everyone. New update of both repos.

All goals in MQL5-JSON-API was done.
Pending orders in Backtrader-MQL5-API was finished.
We will start production testing next week.

New update of both repos.

MQL5 JSON API is finished. Historical data load speed was optimized. I have to finish various features like:

• expiration
• deviation
• hedging
• error handling docs
• etc.

Reconnection and data uploading after reconnection were added to Backtrader-MQL5-API The main goal for now is to finish pending orders management.

@ciceron hi again.
I was wrong. Oanda broker has StopTrail implementation.

if order.exectype == bt.Order.StopTrail:
    okwargs['distance'] = order.trailamount 

https://github.com/ftomassetti/backtrader-oandav20/blob/master/btoandav20/stores/oandav20store.py

I didn't have any practice with Oanda broker, so i don't know how stoptrail works on Oanda side. But your understanding is correct for backtesting.

Hi Ciceron.

As i see Oanda broker doesn't have trailing stop implementation. Only:

# Order type matching with oanda
_ORDEREXECS = {
    bt.Order.Market: 'MARKET',
    bt.Order.Limit: 'LIMIT',
    bt.Order.Stop: 'STOP',
    bt.Order.StopLimit: 'STOP',
}

https://github.com/ftomassetti/backtrader-oandav20/blob/master/btoandav20/stores/oandav20store.py

Hello everyone,

I have released Backtrader-MQL5-API stable beta. MQL5 has complex order management logic, so i have some headache implementing it to backtrader. )) Only market orders working right now. It will take some time to finish pending orders.

self.position doesn't work too. Because of threading next happens several times before position approval returns from MQL5. @backtrader Do you have any idea how to fix it? Thanks.

Hi. I think that you should add exectype param.

p1 = 100
p2 = p1 - 0,01 * p1
p3 = p1 + 0,01 * p1

self.buy_bracket(price=p1, stopprice=p2, limitprice=p3, exectype=bt.Order.Limit)

I use PyCharm Pro.

I have released stable beta MQL5 JSON API. Most part of the documentation is also ready. See it on github.

Backtrader MQL broker stable beta is almost ready too. Don't use alfa release of the broker. The code would not work because MQL side was refactored.

@Tomas
Hi. I wrote an example strategy for you. You can access the indicator lines through the name in __init__ method.

class CryptoStochRSI(bt.Strategy):

    params = (
        ('stoch_k_period', 3),
        ('stoch_d_period', 3),
        ('stoch_rsi_period', 14),
        ('stoch_period', 14),
        ('stoch_upperband', 80.0),
        ('stoch_lowerband', 20.0),

        ('take_profit', 0.04),
        ('stop_loss', 0.01),

        ('size', 20),
        ('debug', False),
    )

    def __init__(self):

        self.stoch = StochasticRSI(k_period=self.p.stoch_k_period,
                                   d_period=self.p.stoch_d_period,
                                   rsi_period=self.p.stoch_rsi_period,
                                   stoch_period=self.p.stoch_period,
                                   upperband=self.p.stoch_upperband,
                                   lowerband=self.p.stoch_lowerband)

    def next(self):

        if not self.position:
            close = self.data.close[0]
            price1 = close
            price2 = price1 - self.p.stop_loss * close
            price3 = price1 + self.p.take_profit * close

            if self.stoch.l.fastk[0] < 20:
                self.buy_bracket(price=price1, stopprice=price2, limitprice=price3, exectype=bt.Order.Limit)

            if self.stoch.l.fastk[0] > 80:
                self.sell_bracket(price=price1, stopprice=price3, limitprice=price2, exectype=bt.Order.Limit)

Hi, everyone.

This is a MQL style Zigzag indicator written for live trading. It has 2 params: first is retrace - retracement in percent, second one is minbars - how many bars indicator will skip after last extremum before searching opposite extremum. The logic of indicator is quite complex, but it works. )

TODO: Handle the outer bar. It is a bar witch values being higher and lower at the same time than last extremum value.

If you find any bug, please, let me know.

##+------------------------------------------------------------------+
## Copyright (C) 2019 Nikolai Khramkov
##
## This program is free software: you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation, either version 3 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
## You should have received a copy of the GNU General Public License
## along with this program.  If not, see <http://www.gnu.org/licenses/>.
##+------------------------------------------------------------------+


import backtrader as bt

class ZigZag(bt.ind.PeriodN):
    '''
      ZigZag indicator.
    '''
    lines = (
        'trend',
        'last_high',
        'last_low',
        'zigzag',
    )

    plotinfo = dict(
        subplot=False,
        plotlinelabels=True, plotlinevalues=True, plotvaluetags=True,
    )

    plotlines = dict(
        trend=dict(_plotskip=True),
        last_high=dict(color='green', ls='-', _plotskip=True),
        last_low=dict(color='black', ls='-', _plotskip=True),
        zigzag=dict(_name='zigzag', color='blue', ls='-', _skipnan=True),
    )

    params = (
        ('period', 2),
        ('retrace', 0.05), # in percent
        ('minbars', 2), # number of bars to skip after the trend change
    )

    def __init__(self):
        super(ZigZag, self).__init__()

        assert self.p.retrace > 0, 'Retracement should be above zero.'
        assert self.p.minbars >= 0, 'Minimal bars should be >= zero.'

        self.ret = self.data.close * self.p.retrace / 100
        self.minbars = self.p.minbars
        self.count_bars = 0
        self.last_pivot_t = 0
        self.last_pivot_ago = 0

    def prenext(self):
        self.l.trend[0] = 0
        self.l.last_high[0] = self.data.high[0]
        self.l.last_low[0] = self.data.low[0]
        self.l.zigzag[0] = (self.data.high[0] + self.data.low[0]) / 2

    def next(self):
        curr_idx = len(self.data)
        self.ret = self.data.close[0] * self.p.retrace / 100
        self.last_pivot_ago = curr_idx - self.last_pivot_t
        self.l.trend[0] = self.l.trend[-1]
        self.l.last_high[0] = self.l.last_high[-1]
        self.l.last_low[0] = self.l.last_low[-1]
        self.l.zigzag[0] = float('nan')

        # Search for trend
        if self.l.trend[-1] == 0:
            if self.l.last_low[0] < self.data.low[0] and self.l.last_high[0] < self.data.high[0]:
                self.l.trend[0] = 1
                self.l.last_high[0] = self.data.high[0]
                self.last_pivot_t = curr_idx

            elif self.l.last_low[0] > self.data.low[0] and self.l.last_high[0] > self.data.high[0]:
                self.l.trend[0] = -1
                self.l.last_low[0] = self.data.low[0]
                self.last_pivot_t = curr_idx

        # Up trend
        elif self.l.trend[-1] == 1:
            if self.data.high[0] > self.l.last_high[-1]:
                self.l.last_high[0] = self.data.high[0]
                self.count_bars = self.minbars
                self.last_pivot_t = curr_idx

            elif self.count_bars <= 0 and self.l.last_high[0] - self.data.low[0] > self.ret and self.data.high[0] < self.l.last_high[0]:
                self.l.trend[0] = -1
                self.count_bars = self.minbars
                self.l.last_low[0] = self.data.low[0]
                self.l.zigzag[-self.last_pivot_ago] = self.l.last_high[0]
                self.last_pivot_t = curr_idx

            elif self.count_bars < self.minbars and self.data.close[0] < self.l.last_low[0]:
                self.l.trend[0] = -1
                self.count_bars = self.minbars
                self.l.last_low[0] = self.data.low[0]
                self.l.zigzag[-self.last_pivot_ago] = self.l.last_high[0]
                self.last_pivot_t = curr_idx

        # Down trend
        elif self.l.trend[-1] == -1:
            if self.data.low[0] < self.l.last_low[-1]:
                self.l.last_low[0] = self.data.low[0]
                self.count_bars = self.minbars
                self.last_pivot_t = curr_idx

            elif self.count_bars <= 0 and self.data.high[0] - self.l.last_low[0] > self.ret and self.data.low[0] > self.l.last_low[0]:
                self.l.trend[0] = 1
                self.count_bars = self.minbars
                self.l.last_high[0] = self.data.high[0]
                self.l.zigzag[-self.last_pivot_ago] = self.l.last_low[0]
                self.last_pivot_t = curr_idx

            elif self.count_bars < self.minbars and self.data.close[0] > self.l.last_high[-1]:
                self.l.trend[0] = 1
                self.count_bars = self.minbars
                self.l.last_high[0] = self.data.high[0]
                self.l.zigzag[-self.last_pivot_ago] = self.l.last_low[0]
                self.last_pivot_t = curr_idx

        # Decrease minbars counter
        self.count_bars -= 1