quick_trade

)

Dependencies:
 ├──ta (Bukosabino   https://github.com/bukosabino/ta (by Darío López Padial))
 ├──plotly (https://github.com/plotly/plotly.py)
 ├──pandas (https://github.com/pandas-dev/pandas)
 ├──numpy (https://github.com/numpy/numpy)
 ├──tqdm (https://github.com/tqdm/tqdm)
 ├──scikit-learn (https://github.com/scikit-learn/scikit-learn)
 └──ccxt (https://github.com/ccxt/ccxt)

Documentation: 🚧 https://quick-trade.github.io/quick_trade/#/ 🚧
Twitter: @quicktrade_tw
Discord: quicktrade

Installation:

Quick install:

$ pip3 install quick-trade

For development:

$ git clone https://github.com/quick-trade/quick_trade.git
$ pip3 install -r quick_trade/requirements.txt
$ cd quick_trade
$ python3 setup.py install
$ cd ..

Customize your strategy!

from quicktrade.plots import TraderGraph, maketrader_figure
import ccxt
from quick_trade import strategy, TradingClient, Trader
from quick_trade.utils import TradeSide
class MyTrader(qtr.Trader):     @strategy     def strategyselland_hold(self):         ret = []         for i in self.df['Close'].values:             ret.append(TradeSide.SELL)         self.returns = ret         self.setcreditleverages(2)  # if you want to use a leverage         self.setopenstopandtake(stop)         # or... set a stop loss with only one line of code         return ret
client = TradingClient(ccxt.binance()) df = client.getdatahistorical("BTC/USDT") trader = MyTrader("BTC/USDT", df=df) trader.connectgraph(TraderGraph(maketrader_figure())) trader.set_client(client) trader.strategyselland_hold() trader.backtest()

Find the best strategy!

import quick_trade as qtr
import ccxt
from quick_trade.tuner import *
from quick_trade import TradingClient
class Test(qtr.ExampleStrategies):     @strategy     def strategysupertrend1(self, plot: bool = False, stargs, *st_kwargs):         self.strategysupertrend(plot=plot, stargs, *st_kwargs)         self.convert_signal()  # only long trades         return self.returns
@strategy     def macd(self, histogram=False, **kwargs):         if not histogram:             self.strategy_macd(**kwargs)         else:             self.strategymacdhistogram_diff(**kwargs)         self.convert_signal()         return self.returns
@strategy     def psar(self, **kwargs):         self.strategyparabolicSAR(plot=False, **kwargs)         self.convert_signal()         return self.returns
params = {     'strategy_supertrend1':         [             {                 'multiplier': Linspace(0.5, 22, 5)             }         ],     'macd':         [             {                 'slow': Linspace(10, 100, 3),                 'fast': Linspace(3, 60, 3),                 'histogram': Choise([False, True])             }         ],     'psar':         [             {                 'step': 0.01,                 'max_step': 0.1             },             {                 'step': 0.02,                 'max_step': 0.2             }         ]
}
tuner = QuickTradeTuner(     TradingClient(ccxt.binance()),     ['BTC/USDT', 'OMG/USDT', 'XRP/USDT'],     ['15m', '5m'],     [1000, 700, 800, 500],     params )
tuner.tune(Test) print(tuner.sort_tunes()) tuner.save_tunes('quick-trade-tunes.json')  # save tunes as JSON

You can also set rules for arranging arguments for each strategy by using RULES and kwargs to access the values of the arguments:

params = {
    'strategy3sma':
        [
            dict(
                plot=False,
                slow=Choise([2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]),
                fast=Choise([2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]),
                mid=Choise([2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597]),
                RULES='kwargs["slow"] > kwargs["mid"] > kwargs["fast"]'
            )
        ],
}

User's code example (backtest)

from quick_trade import brokers
from quicktrade import tradingsys as qtr
from quick_trade.plots import *
import ccxt
from numpy import inf
client = brokers.TradingClient(ccxt.binance()) df = client.getdatahistorical('BTC/USDT', '15m', 1000) trader = qtr.ExampleStrategies('BTC/USDT', df=df, interval='15m') trader.set_client(client) trader.connectgraph(TraderGraph(maketraderfigure(height=731, width=1440, rowheights=[10, 5, 2]))) trader.strategy2sma(55, 21) trader.backtest(deposit=1000, commission=0.075, bet=inf)  # backtest on one pair

Output plotly chart:

Output print

losses: 12
trades: 20
profits: 8
mean year percentage profit: 215.1878652911773%
winrate: 40.0%
mean deviation: 2.917382949881604%
Sharpe ratio: 0.02203412259055281
Sortino ratio: 0.02774402450236864
calmar ratio: 21.321078596349782
max drawdown: 10.092728860725552%

Run strategy

Use the strategy on real moneys. YES, IT'S FULLY AUTOMATED!

import datetime
from quicktrade.tradingsys import ExampleStrategies
from quick_trade.brokers import TradingClient
from quicktrade.plots import TraderGraph, makefigure
import ccxt
ticker = 'MATIC/USDT'
start_time = datetime.datetime(2021,  # year                                6,  # month                                24,  # day
5,  # hour                                16,  # minute                                57)  # second (Leave a few seconds to download data from the exchange)
class MyTrade(ExampleStrategies):     @strategy     def strategy(self):         self.strategy_supertrend(multiplier=2, length=1, plot=False)         self.convert_signal()         self.setcreditleverages(1)         self.sltpadder(10)         return self.returns
keys = {'apiKey': 'your api key',         'secret': 'your secret key'} client = TradingClient(ccxt.binance(config=keys))  # or any other exchange
trader = MyTrade(ticker=ticker,                  interval='1m',                  df=client.getdatahistorical(ticker, limit=10)) fig = maketraderfigure() graph = TraderGraph(figure=fig) trader.connect_graph(graph) trader.set_client(client)
trader.realtime_trading(     strategy=trader.strategy,     starttime=starttime,     ticker=ticker,     limit=100,     waitsltp_checking=5 )