Metadata-Version: 1.1
Name: kinetick
Version: 1.0.5
Summary: Simplifying Trading
Home-page: https://github.com/imvinaypatil/kinetick
Author: vin8tech
Author-email: UNKNOWN
License: LGPL
Description: `>_• <./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/VhQ3sddp
            :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 so that you can focus on building strategies.
        
        `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
        ========
        
        - 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 <http://zeromq.org>`_ (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 <https://t.me/botfather>`_ token).
        - Full integration with `TA-Lib <https://pypi.org/project/TA-Lib/>`_ via dedicated module (`see example <strategies/macd_super_strategy.py>`_).
        - Ability to import any Python library (such as `scikit-learn <http://scikit-learn.org>`_ or `TensorFlow <https://www.tensorflow.org>`_) 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 <https://www.docker.com>`_ lives
        
        -----
        
        Installation
        ============
        
        Install using ``pip``:
        
        .. code:: bash
        
            $ pip install kinetick
        
        
        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.
        
        
        1. 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
        
        
        2. 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.
        
        
        3. Login to bot
        ----------------------
        
        While the Strategy running in the background:
        
          Assuming you have added the telegram bot to your chat
        
        - ``/login <password>`` - password can be found in the strategy console.
        
        commands
        --------
        
        - ``/report`` - get overview about trades
        - ``/help`` - get help
        - ``/reset-rms`` - resets RiskAssessor parameters to its initial values.
        
        
        
        Configuration
        -------------
        Can be specified either as env variable or cmdline arg
        
        .. list-table::
        
           * - option
             - required?
             - example
             - default
             - note
           * - ``symbols``
             -
             -  symbols=./symbols.csv
             -
             -
           * - ``LOGLEVEL``
             -
             - LOGLEVEL=DEBUG
             - INFO
             -
           * - ``zerodha_user``
             - yes - if live trading
             - zerodha_user=ABCD
             -
             -
           * - ``zerodha_password``
             - yes - if live trading
             - zerodha_password=abcd
             -
             -
           * - ``zerodha_pin``
             - yes - if live trading
             - zerodha_pin=1234
             -
             -
           * - ``BOT_TOKEN``
             - optional
             - BOT_TOKEN=12323:asdcldf..
             -
             - IF not provided then orders will bypass
           * - ``initial_capital``
             - yes
             - initial_capital=10000
             - 1000
             - Max capital deployed
           * - ``initial_margin``
             - yes
             - initial_margin=1000
             - 100
             - Not to be mistaken with broker margin. This is the max amount you can afford to loose
           * - ``initial_margin``
             - yes
             - initial_margin=1000
             - 100
             - Not to be mistaken with broker margin. This is the max amount you can afford to loose
           * - ``risk2reward``
             - yes
             - risk2reward=1.2
             - 1
             - Set risk2reward for your strategy. This will be used in determining qty to trade
           * - ``risk_per_trade``
             - yes
             - risk_per_trade=200
             - 100
             - Risk you can afford with each trade
           * - ``max_trades``
             - yes
             - max_trades=2
             - 1
             - Max allowed concurrent positions
           * - ``dbport``
             -
             - dbport=27017
             - 27017
             -
           * - ``dbhost``
             -
             - dbhost=localhost
             - localhost
             -
           * - ``dbuser``
             -
             - dbuser=user
             -
             -
           * - ``dbpassword``
             -
             - dbpassword=pass
             -
             -
           * - ``dbname``
             -
             - dbname=kinetick
             - kinetick
             -
           * - ``orderbook``
             -
             - orderbook=true
             - false
             - Enable orderbook stream
           * - ``resolution``
             -
             - resolution=1m
             - 1
             - Min Bar interval
        
        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
        
        
        .. 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.
        
        
Keywords: kinetick algotrading algo trading zerodha brokers stocks
Platform: any
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Development Status :: 4 - Beta
Classifier: Operating System :: OS Independent
Classifier: Intended Audience :: Developers
Classifier: Topic :: Office/Business :: Financial
Classifier: Topic :: Office/Business :: Financial :: Investment
Classifier: Topic :: Software Development :: Libraries
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Programming Language :: Python :: 3.4
Classifier: Programming Language :: Python :: 3.5
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
