Kinetick Trade Bot
Kinetick is a framework for creating and running trading strategies without worrying about integration with broker and data streams (currently integrates with zerodha [*]). Kinetick is aimed to make systematic trading available for everyone.
Leave the heavy lifting to kinetick so that you can focus on building strategies.
- A continuously-running Blotter that lets you capture market data even when your algos aren’t running.
- Tick, Bar and Trade data is stored in MongoDB for later analysis and backtesting.
- Using pub/sub architecture using ØMQ (ZeroMQ) for communicating between the Algo and the Blotter allows for a single Blotter/multiple Algos running on the same machine.
- Support for Order Book, Quote, Time, Tick or Volume based strategy resolutions.
- Includes many common indicators that you can seamlessly use in your algorithm.
- Market data events use asynchronous, non-blocking architecture.
- Realtime alerts and order confirmation delivered to your mobile via Telegram bot (requires a Telegram bot token).
- Full integration with TA-Lib via dedicated module (see example).
- Ability to import any Python library (such as scikit-learn or TensorFlow) to use them in your algorithms.
- Live charts powered by TradingView
- RiskAssessor to manage and limit the risk even if strategy goes unexpected
- Power packed batteries included
- Deploy wherever Docker lives
There are 5 main components in Kinetick:
Bot– sends alert and signals with actions to perform.
Blotter– handles market data retrieval and processing.
Broker– sends and process orders/positions (abstracted layer).
Algo– (sub-class of
Broker) communicates with the
Blotterto pass market data to your strategies, and process/positions orders via
- Lastly, Your Strategies, which are sub-classes of
Algo, handle the trading logic/rules. This is where you’ll write most of your code.
1. Get Market Data
To get started, you need to first create a Blotter script:
# blotter.py from kinetick.blotter import Blotter class MainBlotter(Blotter): pass # we just need the name if __name__ == "__main__": blotter = MainBlotter() blotter.run()
Then run the Blotter from the command line:
If your strategy needs order book / market depth data, add the
--orderbook flag to the command:
$ python -m blotter --orderbook
2. Write your Algorithm
While the Blotter running in the background, write and execute your algorithm:
<div class=”highlight highlight-source-python position-relative” data-snippet-clipboard-copy-content=”# strategy.py
from kinetick.algo import Algo
def on_fill(self, instrument, order):
def on_quote(self, instrument):
def on_orderbook(self, instrument):
def on_tick(self, instrument):
def on_bar(self, instrument):
# get instrument history
bars = instrument.get_bars(window=100)
# or get all instruments history
# bars = self.bars[-20:]
# skip first 20 days to get full windows
# strategy.py from kinetick.algo import Algo class CrossOver(Algo): def on_start(self): pass def on_fill(self, instrument, order): pass def on_quote(self, instrument): pass def on_orderbook(self, instrument): pass def on_tick(self, instrument): pass def on_bar(self, instrument): # get instrument history bars = instrument.get_bars(window=100) # or get all instruments history # bars = self.bars[-20:] # skip first 20 days to get full windows if len(bars) < 20: return # compute averages using internal rolling_mean bars['short_ma'] = bars['close'].rolling(window=10).mean() bars['long_ma'] = bars['close'].rolling(window=20).mean() # get current position data positions = instrument.get_positions() # trading logic - entry signal if bars['short_ma'].crossed_above(bars['long_ma'])[-1]: if not instrument.pending_orders and positions["position"] == 0: """ buy one contract. WARNING: buy or order instrument methods will bypass bot and risk assessor. Instead, It is advised to use create_position, open_position and close_position instrument methods to route the order via bot and risk assessor. """ instrument.buy(1) # record values for later analysis self.record(ma_cross=1) # trading logic - exit signal elif bars['short_ma'].crossed_below(bars['long_ma'])[-1]: if positions["position"] != 0: # exit / flatten position instrument.exit() # record values for later analysis self.record(ma_cross=-1) if __name__ == "__main__": strategy = CrossOver( instruments = ['ACC', 'SBIN'], # scrip symbols resolution = "1T", # Pandas resolution (use "K" for tick bars) tick_window = 20, # no. of ticks to keep bar_window = 5, # no. of bars to keep preload = "1D", # preload 1 day history when starting timezone = "Asia/Calcutta" # convert all ticks/bars to this timezone ) strategy.run()
The resulting trades be saved in
~/orders/STRATEGY_YYYYMMDD.csv for later analysis.
Thanks to @ran aroussi for all his initial work with Qtpylib. Most of work here is derived from his library
Kinetick is licensed under the Apache License, Version 2.0. A copy of which is included in LICENSE.txt.
All trademarks belong to the respective company and owners. Kinetick is not affiliated to any entity.