search

imvinaypatil / kinetick

Framework for creating and running trading strategies. Blatantly stolen copy of qtpylib to make it work for Indian markets.
Apache License 2.0
72 stars 36 forks source link
algotrading hacktoberfest stock-market zerodha

readme

>_• <./resources/kinetick512.png>_ Kinetick Trade Bot

.. image:: .resources/kinetick-beta128.png :height: 128 :width: 128 :alt: >_•

\

.. image:: https://img.shields.io/github/checks-status/imvinaypatil/kinetick/main :target: https://github.com/imvinaypatil/kinetick :alt: Branch state

.. image:: https://img.shields.io/badge/python-3.4+-blue.svg?style=flat :target: https://pypi.python.org/pypi/kinetick :alt: Python version

.. image:: https://img.shields.io/pypi/v/kinetick.svg?maxAge=60 :target: https://pypi.python.org/pypi/kinetick :alt: PyPi version

.. image:: https://img.shields.io/discord/881151290741256212?logo=discord :target: https://discord.gg/xqD6RmqvBV :alt: Chat on Discord

\

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 and you focus on building strategies.

WARNING

This project is still in its early stages, please be cautious when dealing with real money.

Changelog » <./CHANGELOG.rst>_

📱 Screenshots

.. |screen1| image:: .resources/screenshot1.jpeg :scale: 100% :align: middle .. |screen2| image:: .resources/screenshot2.jpeg :scale: 100% :align: top .. |screen3| image:: .resources/screenshot3.jpeg :scale: 100% :align: middle

+-----------+-----------+-----------+ | |screen1| | |screen2| | |screen3| | +-----------+-----------+-----------+

Features

Installation

Install using pip:

.. code:: bash

$ pip install kinetick

Telegram bot must be configured in order to take TOTP input for zerodha login

use ``/zlogin <totp>`` command to login to zerodha

Quickstart

There are 5 main components in Kinetick:

  1. Bot - sends alert and signals with actions to perform.

  2. Blotter - handles market data retrieval and processing.

  3. Broker - sends and process orders/positions (abstracted layer).

  4. Algo - (sub-class of Broker) communicates with the Blotter to pass market data to your strategies, and process/positions orders via Broker.

  5. Lastly, Your Strategies, which are sub-classes of Algo, handle the trading logic/rules. This is where you'll write most of your code.

  6. Get Market Data

To get started, you need to first create a Blotter script:

.. code:: python

# 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:

.. code:: bash

$ python -m blotter

If your strategy needs order book / market depth data, add the --orderbook flag to the command:

.. code:: bash

$ python -m blotter --orderbook

  1. Write your Algorithm

While the Blotter running in the background, write and execute your algorithm:

.. code:: python

# 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()

To run your algo in a live environment, from the command line, type:

.. code:: bash

$ python -m strategy --logpath ~/orders

The resulting trades be saved in ~/orders/STRATEGY_YYYYMMDD.csv for later analysis.

  1. Login to bot

While the Strategy running in the background:

Assuming you have added the telegram bot to your chat

commands

Configuration

Can be specified either as env variable or cmdline arg

.. list-table::

Docker Instructions

  1. Build blotter

    $ docker build -t kinetick:blotter -f blotter.Dockerfile .

  2. Build strategy

    $ docker build -t kinetick:strategy -f strategy.Dockerfile .

  3. Run with docker-compose

    $ docker compose up

Backtesting

.. code:: bash

$ python -m strategy --start "2021-03-06 00:15:00" --end "2021-03-10 00:15:00" --backtest --backfill

.. note::

To get started checkout the patented BuyLowSellHigh strategy in ``strategies/`` directory.

🙏 Credits

Thanks to @ran aroussi for all his initial work with Qtpylib. Most of work here is derived from his library

Disclaimer

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.

.. [*] Kinetick is not affiliated to zerodha.