diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..d66af95 --- /dev/null +++ b/.gitignore @@ -0,0 +1,139 @@ + +# Created by https://www.gitignore.io/api/python + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# vscode +.vscode/ + +# databases +*.sqlite3 +*.h5 + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +### Python Patch ### +.venv/ + +### Python.VirtualEnv Stack ### +# Virtualenv +# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/ +[Bb]in +[Ii]nclude +[Ll]ib +[Ll]ib64 +[Ll]ocal +[Ss]cripts +pyvenv.cfg +pip-selfcheck.json + + +# End of https://www.gitignore.io/api/python diff --git a/notebooks/DataStructures.ipynb b/notebooks/DataStructures.ipynb new file mode 100644 index 0000000..c44b78f --- /dev/null +++ b/notebooks/DataStructures.ipynb @@ -0,0 +1,495 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Python primer\n", + "This tutorial assumes you have installed python 3 via [anaconda].(https://www.anaconda.com/download/) and using jupyter notebook\n", + "\n", + "This is an extremely basic introduction to Python to get you started. This is not a python tutorial per se. If you want a more formal and thorough start to python, I recommend this excellent course from [datacamp](https://www.datacamp.com/courses/intro-to-python-for-data-science)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We need some sort of a structure to store data. These are called data structures. We would now dive into 2 basic data structures provided by Python\n", + " - lists\n", + " - dictionaries\n", + " \n", + "**Lists** are simply arrays that are indexed by numbers.\n", + "\n", + "**Dictionaries** are simple key-value pairs.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Lists\n", + "\n", + "Lists in python start and end with a square bracket; items inside a list are separated by commas. Lists can contain anything within it and not restricted to a particular type; even an another list. Lists are indexed starting with 0.\n", + "\n", + "```python\n", + "# This is a list with 4 elements\n", + "a_list = [1,2,3,4]\n", + "```\n", + "\n", + "You can access the items in a list by using the same square brackets\n", + "```python\n", + "a_list[0] # returns 1 since list index start with zero\n", + "```\n", + "\n", + "See the below examples" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 'a', 'b', 'c', 0.5, 'hello', [10, 20, 30]]\n", + "0\n", + "[10, 20, 30]\n", + "hello\n", + "[0, 1, 2, 3, 'a']\n" + ] + } + ], + "source": [ + "# This is a list with 10 items\n", + "a_list = [0,1,2,3,'a','b','c',0.5,'hello',[10,20,30]]\n", + "print(a_list)\n", + "\n", + "# Get the first item\n", + "print(a_list[0])\n", + "\n", + "# Get the last item\n", + "print(a_list[9])\n", + "\n", + "# Get the second last item, the 9th item\n", + "print(a_list[-2])\n", + "\n", + "# Access the first five elements\n", + "print(a_list[0:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As seen in the above example you could use the minus sign to access items backwards. So -1 mean the last item, -2 mean the second last and so on.\n", + "\n", + "You could also use the colon, *called the slice operator*, to get more than one items. The syntax is ```list[start:end:step]``` where \n", + " - start is the starting item you want to get\n", + " - end is the final item you want to get\n", + " - step is the step size taken at each access\n", + " \n", + "**Note, to get the first 4 items, you should use list[0:4] and not 3 since python doesn't get the last item.**\n", + "\n", + "See the examples below" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2]\n", + "[0, 1, 2]\n", + "[0, 2, 'a', 'c', 'hello']\n", + "['c', 0.5, 'hello', [10, 20, 30]]\n" + ] + }, + { + "data": { + "text/plain": [ + "10" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Would fetch the first 3 items, not the fourth one\n", + "print(a_list[0:3])\n", + "\n", + "# Same as above\n", + "print(a_list[:3])\n", + "\n", + "# Get items 1,3,5,7,9\n", + "print(a_list[0::2]) # 2 is the step size\n", + "\n", + "# Get the last 4 items\n", + "print(a_list[-4:]) \n", + "\n", + "# Use the len function to know the length of the list\n", + "len(a_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can add, remove, find an item in a list" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2, 3, 'a', 'b', 'c', 0.5, 'hello', [10, 20, 30], 'add']\n", + "[0, 1, 3, 'a', 'b', 'c', 0.5, 'hello', [10, 20, 30], 'add']\n", + "3\n", + "1\n", + "['add', [10, 20, 30], 'hello', 0.5, 'c', 'b', 'a', 3, 1, 0]\n" + ] + } + ], + "source": [ + "# Append adds an item to the list\n", + "a_list.append('add')\n", + "print(a_list)\n", + "\n", + "# Remove an item by value - removes only the first occurence\n", + "a_list.remove(2)\n", + "print(a_list)\n", + "\n", + "# Find the index of an items - returns only the first index\n", + "print(a_list.index('a'))\n", + "\n", + "# Count the number of occurences of an item\n", + "print(a_list.count('a'))\n", + "\n", + "# Reverse the entire list\n", + "a_list.reverse()\n", + "print(a_list)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Nested lists\n", + "You can have list inside a list inside a list and so on. Use the appropriate number of square brackets to get the required item.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2]\n", + "1\n", + "6\n", + "11\n" + ] + } + ], + "source": [ + "# A deeply nested list. Play with it to understand it\n", + "nested_list = [\n", + " [1,2], \n", + " [3,4,[5,6]], \n", + " [7,8,[9,[10,11,12]]]\n", + "]\n", + "\n", + "print(nested_list[0]) \n", + "print(nested_list[0][0])\n", + "print(nested_list[1][2][1])\n", + "print(nested_list[2][2][1][1])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dictionaries\n", + "\n", + "Dictionaries are simple key-value pairs. Dictionaries in python start and end with curly braces, key and value are separated by colon and key value pairs are separated by commas. You can access\n", + "\n", + "```python\n", + "a_dict = {'firstName': 'John', 'lastName': 'Smith', 'age': 25}\n", + "```\n", + "\n", + "You can access the individual values by keys with a square bracket\n", + "```python\n", + "a_dict['firstName'] # returns John\n", + "```\n", + "\n", + "A few points to note\n", + "\n", + "- a dictionary is a hash implementation\n", + "- keys in dictionary are **unique not sorted**; they are not accessible by index\n", + "- you cannot lookup a key for a value directly\n", + "- values could be anything, even an another dictionary\n", + "- keys could also by anything but strings are preferred for consistency\n", + "- you can access only one key at a time" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'firstName': 'John', 'lastName': 'Smith', 'age': 25}\n", + "25\n", + "{'firstName': 'John', 'lastName': 'Smith', 'age': 31, 'gender': 'Male'}\n" + ] + } + ], + "source": [ + "# A simple dictionary\n", + "a_dict = {'firstName': 'John', 'lastName': 'Smith', 'age': 25}\n", + "print(a_dict)\n", + "\n", + "# Get an item\n", + "print(a_dict['age'])\n", + "\n", + "# Set an item\n", + "a_dict['age'] = 31\n", + "# Add a new item\n", + "a_dict['gender'] = 'Male'\n", + "print(a_dict)\n", + "\n", + "# Remove an item\n", + "del a_dict['gender']" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "dict_keys(['firstName', 'lastName', 'age'])\n", + "dict_values(['John', 'Smith', 31])\n", + "{'firstName': 'John', 'lastName': 'Smith', 'age': 31, 'employed': True, 'middleName': 'Richard'}\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Get all the keys\n", + "print(a_dict.keys())\n", + "\n", + "# Get all the values\n", + "print(a_dict.values())\n", + "\n", + "# Update multiple items\n", + "a_dict.update({'employed': True, 'middleName': 'Richard'})\n", + "print(a_dict)\n", + "\n", + "# Check if a key is in a dictionary\n", + "'middleName' in a_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Nested dictionaries\n", + "\n", + "You could combine dictionaries within dictionaries within dictionaries and so on similar to lists. Use appropriate square brackets to get the value.\n", + "\n", + "You could create any data structure with this approach." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "3\n", + "John\n" + ] + } + ], + "source": [ + "nested_dict = {\n", + " 'a': 1,\n", + " 'b': 2,\n", + " 'points': {'x': 3, 'y': 2, 'z': 10},\n", + " 'person':\n", + " {\n", + " 'name':\n", + " {\n", + " 'first': 'John',\n", + " 'last': 'Smith'\n", + " }\n", + " }\n", + "}\n", + "print(nested_dict['a'])\n", + "print(nested_dict['points']['x'])\n", + "print(nested_dict['person']['name']['first'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combining lists and dictionaries\n", + "\n", + "You can combine lists and dictionaries in various ways to create any data structure you need and further build upon them. Since both of them could be nested within each other, they are extremly flexible. \n", + "\n", + "One of the common methods is to either create your data structure as a list of dictionaries or a dictionary of different lists.\n", + "To access such a deeply nested structure use the **right key and index**. \n", + "\n", + "Let's see an example. We would create the following invoice in 2 different ways\n", + "\n", + "product|qty|rate|value|tax|gross\n", + "-------|---|----|-----|---|-----\n", + "a|10|5|50|8|58\n", + "b|1|35|35|0|35\n", + "c|5|8|40|10|50\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a\n", + "a\n" + ] + } + ], + "source": [ + "# A dict of lists\n", + "\n", + "data1 = {\n", + " 'product': ['a', 'b', 'c'],\n", + " 'qty': [10, 1, 5],\n", + " 'rate': [5, 35, 8],\n", + " 'value': [50, 35, 40],\n", + " 'tax': [8, 0, 10],\n", + " 'gross': [58, 35, 50]\n", + "}\n", + "\n", + "# A list of dicts\n", + "data2 = [\n", + " {'product': 'a', 'qty': 10, 'rate': 5, 'value': 50, 'tax': 8, 'gross': 58},\n", + " {'product': 'b', 'qty': 1, 'rate': 35, 'value': 35, 'tax': 0, 'gross': 35},\n", + " {'product': 'c', 'qty': 5, 'rate': 8, 'value': 40, 'tax': 10, 'gross': 50}\n", + "]\n", + "\n", + "print(data1['product'][0])\n", + "print(data2[0]['product'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Sets\n", + "\n", + "Python also provides a set data structure that works exactly like sets in mathematics. \n", + "See a quick introduction to sets [here](https://www.mathsisfun.com/sets/sets-introduction.html)\n", + "\n", + "Its a very useful one for\n", + " - having a unique set of items\n", + " - do common set operations\n", + " \n", + "You could create a set with a pair of curly braces with items separated by commas." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{1, 2, 3, 4, 5}\n", + "{1, 3}\n", + "{2, 4}\n" + ] + } + ], + "source": [ + "set_one = {1, 2, 3, 4}\n", + "set_two = {1, 3, 5}\n", + "\n", + "# Union\n", + "print(set_one.union(set_two))\n", + "\n", + "# Intersection\n", + "print(set_one.intersection(set_two))\n", + "\n", + "# Difference\n", + "print(set_one.difference(set_two))\n", + "\n", + "# The above are just common functions.\n", + "# Python sets provide a full list of set functions you could explore" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/MarketTiming.ipynb b/notebooks/MarketTiming.ipynb new file mode 100644 index 0000000..c098bc4 --- /dev/null +++ b/notebooks/MarketTiming.ipynb @@ -0,0 +1,170 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Market Timing\n", + "\n", + "Market Timing is often considered a strategy for beating the markets and making profits. We would try to explore whether market timing actually works. We would work with the NIFTY index." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "sns.set()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Load your data here\n", + "filename = '/home/machine/Downloads/NIFTY 50_Data.csv'\n", + "df = pd.read_csv(filename, parse_dates=['Date'])\n", + "df.rename(lambda x: x.lower(), axis='columns', inplace=True)\n", + "df = df.set_index('date').sort_index()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dollar averaging method\n", + "\n", + "Dollar averaging is one of the most popular methods used in investment. Under this method, we would buying a stock or an index fund at periodic intervals irrespective of trend. The underlying assumption is equity markets are profitable in the long run and investing them over periodic intervals for a long period of time would lead to the benefits of compounding.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Buy index at the close price of each month; assume integer quantities\n", + "freq = 'M' # buy every month - W for week; 2W for every 2 weeks\n", + "capital = 40000 # investment every period\n", + "df2 = df.resample(freq).close.last().reset_index()\n", + "df2.columns = ['date', 'price']\n", + "df2['avg_price'] = df2.price.expanding().mean()\n", + "df2['capital'] = capital * (df2.index+1)\n", + "df2['qty'] = (capital/df2['price']).astype(int)\n", + "df2['value'] = df2.qty.cumsum() * df2.price\n", + "df2.set_index('date').price.plot(title='Raw price plot of the index')\n", + "df2.set_index('date')[['price', 'avg_price']].plot(title='Average Buy Price')\n", + "df2.set_index('date')[['capital', 'value']].plot(\n", + " title='Invested Capital vs Value of Investment')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So ,it took 4 years before your investment start getting returns on your capital.\n", + "\n", + "You would be in for a surprise if you change the frequency to weekly **W**.\n", + "\n", + "Hint `(capital/df2['price']).astype(int)`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Moving average crossover\n", + "\n", + "One of the most suggested strategies is the moving average crossover where you buy when one moving average crosses another. Let's implement a long only strategy implementing MA crossover.\n", + "\n", + "1. Select two periods ma1, ma2 so that ma1 > ma2\n", + "2. Calculate the simple moving average for the 2 periods\n", + "3. BUY when ma1 > ma2\n", + "4. SELL when ma1 < ma2; hold as long as ma1 > ma2\n", + "5. Enter into a new position only when there are no open positions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from fastbt.tradebook import TradeBook\n", + "\n", + "capital = 100000\n", + "ma1 = 15\n", + "ma2 = 30\n", + "df2 = df.copy()\n", + "df2['ma1'] = df2.rolling(ma1).close.mean()\n", + "df2['ma2'] = df2.rolling(ma2).close.mean()\n", + "\n", + "tb = TradeBook()\n", + "for date,row in df2.dropna().iterrows():\n", + " # Enter into a position only when there are no open positions\n", + " if tb.o == 0:\n", + " if row['ma1'] > row['ma2']:\n", + " qty = int(capital/row['close'])\n", + " tb.add_trade(date, 'NIFTY', row['close'], qty, order='B',\n", + " ma1=row['ma1'], ma2=row['ma2'])\n", + " # Exit in case of an open order\n", + " if tb.o > 0:\n", + " last_qty = abs(tb.trades['NIFTY'][-1]['qty'])\n", + " if row['ma1'] < row ['ma2']:\n", + " tb.add_trade(date, 'NIFTY', row['close'], last_qty, order='S',\n", + " ma1=row['ma1'], ma2=row['ma2'])\n", + " \n", + "# Close any existing position at the end of the period\n", + "if tb.o > 0:\n", + " last_qty = abs(tb.trades['NIFTY'][-1]['qty'])\n", + " tb.add_trade(date, 'NIFTY', row['close'], last_qty, order='S',\n", + " ma1=row['ma1'], ma2=row['ma2'])\n", + "\n", + "# In case of investment left untouched\n", + "return_per_qty = df2.close.iloc[-1] - df2.close.iloc[0] \n", + "start_qty = int(capital/df2.close.iloc[0])\n", + "total_return = return_per_qty * start_qty\n", + "returns_calc = lambda x,y : (x/y)*100\n", + "\n", + "print('Returns when invested and left alone\\nAmount={:.0f}; \\\n", + "Returns={:.2f}%'.format(total_return, returns_calc(total_return, capital)))\n", + "print('Returns from the strategy\\nAmount={:.0f};Returns={:.2f}%'.format(\n", + " tb.values['NIFTY'], returns_calc(tb.values['NIFTY'], capital)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change the ma1 and ma2 parameters to see how the returns vary" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/OptionsBacktesting.ipynb b/notebooks/OptionsBacktesting.ipynb new file mode 100644 index 0000000..7deb0a5 --- /dev/null +++ b/notebooks/OptionsBacktesting.ipynb @@ -0,0 +1,684 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Options Backtesting Framework\n", + "\n", + "This is a simple backtesting framework for options. Given end of day data for both the capital and derivatives markets, we would be backtesting for different strategies.\n", + "\n", + "> All options are opened at the start of the period and closed by the end of the period or by a stop loss if provided\n", + "\n", + "### Implementation\n", + "\n", + "1. Load and transform necessary data\n", + "2. Create a list of option contracts to be entered into each day\n", + "3. Create a list of signals, on whether to enter into the contract, for each day\n", + "4. Extract the necessary data for the options contracts that would be executed\n", + "5. Analyze Profit and loss and other metrics\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# Load necessary libraries\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "import seaborn as sns\n", + "sns.set()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Utility Functions" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def itm(price, opt='C', step=100):\n", + " \"\"\"\n", + " Get the strike price of the in the money option\n", + " price\n", + " spot price\n", + " opt\n", + " option type - C for Call and P for Put\n", + " step\n", + " multiple of option strike price\n", + " \"\"\"\n", + " if opt == 'C':\n", + " return int(price/step)*step\n", + " elif opt == 'P':\n", + " return (int(price/step)+1)*step" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Data Preparation\n", + "-----------------\n", + "Load the raw data and do some transformations. All raw options data is loaded from the bhav copy of the NSE website. Index data is from [niftyindices.com](https://www.niftyindices.com/)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "nifty = pd.read_csv('/home/machine/Downloads/NIFTY 50_Data.csv',\n", + " parse_dates=['Date'])\n", + "nifty.rename(lambda x: x.lower(), axis='columns', inplace=True)\n", + "nifty = nifty[nifty.date.dt.year==2019].sort_values(by='date').reset_index(drop=True)\n", + "\n", + "der = pd.read_hdf('/media/machine/4E1EA2D152455460/data/output/fno_2019.h5')\n", + "der.rename({'timestamp': 'date'}, axis='columns', inplace=True)\n", + "der['exp_day'] = der.expiry_dt.dt.day\n", + "\n", + "# Difference between expiry date and date\n", + "der['day_diff'] = (der['expiry_dt'] - der['date']).dt.days\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4 2019-01-31\n", + "1 2019-02-28\n", + "2 2019-03-28\n", + "0 2019-04-25\n", + "3 2019-05-30\n", + "5 2019-06-27\n", + "dtype: datetime64[ns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Change your symbol here\n", + "symbol = 'NIFTY'\n", + "# Keep nifty data with monthly options only\n", + "# This hack is incomplete and should be correctly configured\n", + "q = '(symbol==\"{sym}\") & (instrument==\"OPTIDX\") & (exp_day > 24) & (day_diff<29)'\n", + "df = der.query(q.format(sym=symbol))\n", + "pd.Series(df.expiry_dt.unique()).sort_values()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Select list of options\n", + "-----------------------\n", + "\n", + "We must now select the list of options to be traded. To begin, with let's BUY in the money call option at the start of the day and hold it till the end of the day. We need the following columns for each day\n", + "\n", + " * date\n", + " * strike price\n", + " * option_type\n", + " * spot price" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def option_prices(prices, opt=[('C',0)], step=100):\n", + " \"\"\"\n", + " Get the list of options for each period\n", + " prices\n", + " prices on which the option prices are to be generated\n", + " series with date as index and price as values\n", + " opt\n", + " list of option type and step as 2-tuples\n", + " * (C,0) mean in-the-money call option\n", + " * (C,1) mean call option next to in-the-money\n", + " * (P,0) mean in-the-money put option\n", + " step\n", + " optional step size for the option\n", + " Note\n", + " -----\n", + " All calculations are done with in-the-money option\n", + " as the reference point. To illustrate, assume a spot price of 10285\n", + " (C,0) -> 10200\n", + " (C,1) -> 10300\n", + " (P,0) -> 10300\n", + " (P,1) -> 10200\n", + " (C,0) with step=50 -> 10250\n", + " (C,1) with step=50 -> 10300\n", + " \"\"\"\n", + " collect = []\n", + " s = prices.reset_index()\n", + " s.columns = ['date', 'spot']\n", + " for opt, strk in opt:\n", + " o = s.copy()\n", + " if opt == 'C':\n", + " o['strike_pr'] = [itm(x, 'C', step)+(strk*step) for x in nifty.open]\n", + " o['option_typ'] = 'CE'\n", + " elif opt == 'P':\n", + " o['strike_pr'] = [itm(x, 'P', step)-(strk*step) for x in nifty.open]\n", + " o['option_typ'] = 'PE'\n", + " collect.append(o)\n", + " return pd.concat(collect)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datestrike_proption_typspot
02019-01-0110800CE10881.70
12019-01-0210800CE10868.85
22019-01-0310700CE10796.80
32019-01-0410600CE10699.70
42019-01-0710800CE10804.85
\n", + "
" + ], + "text/plain": [ + " date strike_pr option_typ spot\n", + "0 2019-01-01 10800 CE 10881.70\n", + "1 2019-01-02 10800 CE 10868.85\n", + "2 2019-01-03 10700 CE 10796.80\n", + "3 2019-01-04 10600 CE 10699.70\n", + "4 2019-01-07 10800 CE 10804.85" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nifty['strike_pr'] = [itm(x) for x in nifty.open]\n", + "nifty['spot'] = nifty.open.copy()\n", + "nifty['option_typ'] = 'CE'\n", + "cols = ['date', 'strike_pr', 'option_typ', 'spot']\n", + "options = nifty[cols].copy()\n", + "options.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datespotstrike_proption_typ
02019-01-0110881.7010800CE
12019-01-0210868.8510800CE
22019-01-0310796.8010700CE
32019-01-0410699.7010600CE
42019-01-0710804.8510800CE
\n", + "
" + ], + "text/plain": [ + " date spot strike_pr option_typ\n", + "0 2019-01-01 10881.70 10800 CE\n", + "1 2019-01-02 10868.85 10800 CE\n", + "2 2019-01-03 10796.80 10700 CE\n", + "3 2019-01-04 10699.70 10600 CE\n", + "4 2019-01-07 10804.85 10800 CE" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "options = option_prices(nifty.set_index('date').open)\n", + "options.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Select signals\n", + "--------------\n", + "\n", + "A signal is a indication whether to buy or sell the contract on a daily basis. It is a single column that outputs 1 if the contract is entered into or a 0 if the contract is not entered. Since we would be trading for all the days, we simply include a 1 for all dates" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
datespotstrike_proption_typsignal
02019-01-0110881.7010800CE1
12019-01-0210868.8510800CE1
22019-01-0310796.8010700CE1
32019-01-0410699.7010600CE1
42019-01-0710804.8510800CE1
\n", + "
" + ], + "text/plain": [ + " date spot strike_pr option_typ signal\n", + "0 2019-01-01 10881.70 10800 CE 1\n", + "1 2019-01-02 10868.85 10800 CE 1\n", + "2 2019-01-03 10796.80 10700 CE 1\n", + "3 2019-01-04 10699.70 10600 CE 1\n", + "4 2019-01-07 10804.85 10800 CE 1" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "options['signal'] = 1\n", + "options.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Merging data and backtesting\n", + "-----------------------------\n", + "Since we have restricted the data at the time of query to only contracts with monthly expiry and to a particular symbol, there would be only one contract with the specific strike and option type on a particular date. So we could go ahead with a simple merge\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "cols = ['symbol', 'date', 'expiry_dt', 'strike_pr', 'option_typ',\n", + " 'open', 'high', 'low', 'close']\n", + "res = options.merge(df[cols], on=['date', 'strike_pr', 'option_typ'])\n", + "res['profit'] = res.eval('close-open') # to change in case of selling options\n", + "res['cum_profit'] = res.profit.cumsum()\n", + "res.set_index('date').cum_profit.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Run a backtest with stop loss and price set\n", + "# pip install fastbt for this to work\n", + "\n", + "from fastbt.rapid import backtest\n", + "df101 = options.merge(df[cols], on=['date', 'strike_pr', 'option_typ'])\n", + "df101['timestamp'] = df101['date']\n", + "results = backtest(data=df101, stop_loss=25, order='B', price='open*1.1')\n", + "results['profit'] = results.eval('sell-buy')\n", + "results.set_index('timestamp').profit.cumsum().plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "results = backtest(data=df101, stop_loss=25, order='S', price='open*0.9')\n", + "results['profit'] = results.eval('sell-buy')\n", + "results.set_index('timestamp').profit.cumsum().plot()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's work out a slightly complex option\n", + "\n", + "1. SELL in the money CALL option\n", + "2. BUY in-the-money + 200 CALL option\n", + "3. BUY in the money PUT option\n", + "4. SELL in-the-money - 100 PUT option\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "opts = [\n", + " ('C', 0),\n", + " ('C', 2),\n", + " ('P', 0),\n", + " ('P', 1)\n", + "]\n", + "mode = ['S', 'B', 'B', 'S']\n", + "collect = []\n", + "for opt, order in zip(opts, mode):\n", + " options = option_prices(nifty.set_index('date').open, [opt])\n", + " cols = ['symbol', 'date', 'expiry_dt', 'strike_pr', 'option_typ',\n", + " 'open', 'high', 'low', 'close']\n", + " res = options.merge(df[cols], on=['date', 'strike_pr', 'option_typ'])\n", + " if order == 'B':\n", + " res['profit'] = res.eval('close-open')\n", + " elif order == 'S':\n", + " res['profit'] = res.eval('open-close')\n", + " collect.append(res)\n", + "all_options = pd.concat(collect).sort_values(by='date')\n", + "all_options.groupby('date').profit.sum().cumsum().plot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/oi_graph/README.md b/oi_graph/README.md new file mode 100644 index 0000000..aa2f52b --- /dev/null +++ b/oi_graph/README.md @@ -0,0 +1,4 @@ +Open Interest Plotting +----------------------- + +Open Interest Plotting with bokeh \ No newline at end of file diff --git a/oi_graph/futures_oi.py b/oi_graph/futures_oi.py new file mode 100644 index 0000000..51ccc2e --- /dev/null +++ b/oi_graph/futures_oi.py @@ -0,0 +1,156 @@ +import pandas as pd +import numpy as np + +from bokeh.io import curdoc +from bokeh.layouts import row, column, gridplot, layout +from bokeh.palettes import Spectral6, Dark2 +from bokeh.models import ColumnDataSource, Range1d, LinearAxis, NumeralTickFormatter +from bokeh.models.widgets import Select, Button +from bokeh.plotting import figure, output_file, show + + +def load_data(): + """ + Load all data into memory + return a dataframe with all the data. + This should be called only once with all data being fetched + """ + return pd.read_hdf('~/Desktop/todaydata.h5') + +def get_open_interest(data, symbol): + """ + Given data and symbol, return the expiry dates and + open_interest for various expiry dates in columns + data + dataframe with all the data + symbol + symbol to extract + return a 2-tuple with list of column names and + a dataframe with open interest + """ + temp = data[data.symbol == symbol] + cols = ['timestamp', 'expiry_dt', 'open_int'] + pivot = temp.pivot(index='timestamp', columns='expiry_dt', values='open_int') + pivot.rename(lambda x: x.strftime('%Y-%m-%d'), + axis='columns', inplace=True) + columns = pivot.columns + pivot['combined_oi'] = pivot.sum(axis=1) + return (columns, pivot.reset_index()) + +def get_price_oi(data, symbol): + """ + Get the price and combined open_interest for the symbol + data + dataframe with all data + symbol + symbol to extract data + """ + temp = data[data.symbol == symbol] + grouped = temp.groupby('timestamp') + agg = grouped.agg({'open_int': sum, 'close': 'mean'}).reset_index() + agg['date'] = agg.timestamp.dt.date.astype(str) + agg['index'] = range(len(agg)) + return agg + +output_file('futures_oi.html') +df = load_data() +symbols = list(df.symbol.unique()) +source = ColumnDataSource() +prices = ColumnDataSource() +pct_chg = ColumnDataSource() + + +# Create widgets +select_symbol = Select(options=symbols, title='Select a symbol', + value='NIFTY') +button = Button(label='Refresh', button_type="success") + +# Create plots +p = figure(title='Open interest chart for NIFTY futures', + x_axis_type='datetime', + tooltips=[ + ('date', '@date'), + ('combined OI', '@combined_oi{0 a}'), + ('expiry_at', '$name q:@$name{0.0 a}') + ],background_fill_color='beige', background_fill_alpha=0.4) +cols, data = get_open_interest(df, 'NIFTY') +data['date'] = data.timestamp.dt.date +colors = Dark2[6][:len(cols)] +source.data = source.from_df(data) +p.yaxis[0].formatter = NumeralTickFormatter(format='0.00 a') +p.vbar_stack(cols, width=3.6e7, x='date', color=colors, source=source, fill_alpha=0.7) + +price_data = get_price_oi(df, 'NIFTY') +prices.data = prices.from_df(price_data) +h0 = price_data['close'].max() +l0 = price_data['close'].min() +h1 = price_data['open_int'].max() +l1 = price_data['open_int'].min() + +p2 = figure(title='Price vs Open Interest', + x_axis_type='datetime', y_range=(l0,h0), + tooltips = [ + ('date', '@timestamp{%F}'), + ('value', '$y{0.00 a}') + ], + background_fill_color='beige', background_fill_alpha=0.4) +p2.line('timestamp', 'close', line_width=2, source=prices) +p2.extra_y_ranges = {'foo': Range1d(l1,h1)} +p2.line('timestamp', 'open_int', source=prices, y_range_name='foo', + line_color='firebrick', line_width=2) +p2.add_layout(LinearAxis(y_range_name='foo'), 'right') +p2.yaxis[1].formatter = NumeralTickFormatter(format='0.0 a') +p2.hover.formatters = {'timestamp': 'datetime'} + +pct_change = data[['date', 'combined_oi']].copy() +pct_change['date'] = pd.to_datetime(pct_change['date']) +pct_change['chg'] = pct_change.combined_oi.pct_change() +pct_chg.data = pct_chg.from_df(pct_change) +p3 = figure(title='Change in open_interest', + x_axis_type='datetime', + tooltips=[ + ('change', '$y{0.00%}') + ], + background_fill_color='beige', background_fill_alpha=0.4) +p3.vbar(x='date', top='chg', width=3.6e7, + fill_alpha=0.7, color='gold', source=pct_chg) + + +# setup callbacks +def update(): + symbol = select_symbol.value + cols, data = get_open_interest(df, symbol) + data['date'] = data.timestamp.dt.date.astype(str) + max_val = data[cols].sum().max() + p.y_range.start = 0 + p.y_range.end = max_val + p.title.text = 'Open interest chart for {} futures'.format(symbol) + source.data = source.from_df(data) + pdata = get_price_oi(df, symbol) + h0 = pdata['close'].max() + l0 = pdata['close'].min() + h1 = pdata['open_int'].max() + l1 = pdata['open_int'].min() + print(symbol, l0, h0, l1, h1) + prices.data = prices.from_df(pdata) + p2.y_range.start = l0 + p2.y_range.end = h0 + p2.extra_y_ranges['foo'].start = l1 + p2.extra_y_ranges['foo'].end = h1 + pct_change = data[['date', 'combined_oi']].copy() + pct_change['chg'] = pct_change.combined_oi.pct_change() + pct_chg.data = pct_chg.from_df(pct_change) + + +# set up event triggers +button.on_click(update) + +grid = gridplot([p2,p,p3], ncols=1, plot_width=640, plot_height=180) +# Display the dashboard +l = layout( + row(select_symbol,button), + grid + ) + +curdoc().add_root(l) +show(l) \ No newline at end of file diff --git a/oi_graph/oi.py b/oi_graph/oi.py new file mode 100644 index 0000000..aa6bd3d --- /dev/null +++ b/oi_graph/oi.py @@ -0,0 +1,135 @@ +import numpy as np +import pandas as pd +import datetime + +from bokeh.io import curdoc, show, output_file +from bokeh.layouts import row, column +from bokeh.plotting import figure +from bokeh.models import ColumnDataSource, FactorRange +from bokeh.models.widgets import Select, TextInput, DatePicker, Button +from bokeh.transform import factor_cmap + +# Load data, probably from a database. I am loading it directly from a file +df = pd.read_hdf('derivatives_may_2019.h5') +symbols = sorted(list(df.symbol.unique())) +source = ColumnDataSource(df) + +def update_expiry_date(attrname, old, new): + """ + Update expiry date for this particular symbol + """ + q = 'symbol == "{}"'.format(new) + dates = sorted(df.query(q).expiry_dt.unique()) + dates = [str(dt)[:10] for dt in dates] + expiry_select.options = dates + expiry_select.value = dates[0] + print(select_symbols, select_symbols.value, date_picker.value) + +def update_oi_chart(): + pass + +def query(dataframe, symbol='NIFTY', date='2019-05-02', expiry='2019-05-30'): + """ + Given a dataframe and query string, return the queried data + """ + cond = '(symbol=="{symbol}") & (timestamp == "{dt}") & (expiry_dt=="{exp}") & (option_typ != "XX")' + q = cond.format(symbol=symbol, dt=str(date)[:10], exp=str(expiry)[:10]) + print('QUERY IS', q) + df2 = dataframe.query(q)[['strike_pr', 'option_typ', 'open_int']] + df2.sort_values(by=['strike_pr'], inplace=True) + return df2 + +def get_data_as_source(data): + """ + Get data in source format + """ + x = [(str(int(a)), str(b)) for a,b in zip(q.strike_pr, q.option_typ)] + source = ColumnDataSource(data=dict(x=x, values=data.open_int.values)) + return source + +def fig1(): + """ + Generate the first figure + """ + q = query(df, symbol=select_symbols.value, date=date_picker.value, + expiry=expiry_select.value) + #q = query(df, symbol='ACC', date='2019-05-23', expiry='2019-05-30') + if (q is None) or (len(q) == 0): + return figure() + + x = [(str(int(a)), str(b)) for a,b in zip(q.strike_pr, q.option_typ)] + source = ColumnDataSource(data=dict(x=x, values=q.open_int.values)) + + TOOLTIPS = [ + ('index', '$index'), + ('open_interest', '@values'), + ('option', '@x') + ] + p = figure(x_range=FactorRange(*x), + title="Open Interest", tooltips=TOOLTIPS, + tools="pan,wheel_zoom,box_zoom,hover,reset") + p.vbar(x='x', top='values', width=0.9, source=source, + fill_color=factor_cmap('x', palette=['red', 'green'], + factors=['PE', 'CE'], start=1, end=2)) + + +def update(): + """ + Update chart data + """ + data = query(df, symbol=select_symbols.value, date=date_picker.value, + expiry=expiry_select.value) + x_range = [(str(int(a)), str(b)) for a,b in + zip(data.strike_pr, data.option_typ)] + p1.x_range.factors = x_range + src = ColumnDataSource({'x': x_range, 'values': data.open_int.values}) + source.data = src.data + + + +# Create widgets +select_symbols = Select(title='Pick a symbol', options=symbols) +expiry_select = Select(title='Select an expiry date', options=None) +date_picker = DatePicker(title='Select a date', + value=datetime.datetime.today().date()) +button = Button(label="Update", button_type="success") + +# Create charts +q = query(df, symbol=select_symbols.value, date=date_picker.value, + expiry=expiry_select.value) +q = query(df, symbol='BANKBARODA') +x = [(str(int(a)), str(b)) for a,b in zip(q.strike_pr, q.option_typ)] +source = ColumnDataSource(data=dict(x=x, values=q.open_int.values)) +TOOLTIPS = [ + ('index', '$index'), + ('open_interest', '@values'), + ('option', '@x') + ] +p1 = figure(x_range=FactorRange(), + title="Open Interest", tooltips=TOOLTIPS, + tools="pan,wheel_zoom,box_zoom,hover,reset") +p1.x_range = FactorRange(*x) +bar = p1.vbar(x='x', top='values', width=0.9, source=source, + alpha=0.7, + fill_color=factor_cmap('x', palette=['red', 'green'], + factors=['PE', 'CE'], start=1, end=2)) + + +# Event handlers +select_symbols.on_change('value', update_expiry_date) +#date_picker.on_change('value', lambda x,y,z: print(z)) +button.on_click(update) + +layout = column( + row(select_symbols, expiry_select), + row(date_picker, button), + row(p1) + ) + +# add the layout to curdoc +curdoc().add_root(layout) + +if __name__ == "__main__": + print('Hello') + + diff --git a/tradingsystem/Backtest.ipynb b/tradingsystem/Backtest.ipynb index 5d41593..5365582 100644 --- a/tradingsystem/Backtest.ipynb +++ b/tradingsystem/Backtest.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -30,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -43,7 +43,7 @@ "CAPITAL = 20000\n", "LEVERAGE = 1\n", "REF_PRICE = 'close'\n", - "COMMISSION = 0 # In percent" + "COMMISSION = 0.03 # In percent" ] }, { @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -92,20 +92,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "41881" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# Now read the entire table back\n", "df = pd.read_sql_table(TABLENAME, engine)\n", @@ -141,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -155,7 +144,7 @@ "grouped = df.groupby('timestamp')\n", "collect = []\n", "for name, group in grouped:\n", - " temp = group.sort_values(by='ret', ascending=False).iloc[:5]\n", + " temp = group.sort_values(by='ret', ascending=False).iloc[:NUM_STOCKS]\n", " collect.append(temp)\n", "orders = pd.concat(collect)\n", " " @@ -163,7 +152,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -176,7 +165,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -192,6 +181,8 @@ " zip(orders['stop_loss'], orders['high'], orders['low'], orders[REF_PRICE])]\n", "orders['profit_per_unit'] = orders['sell'] - orders['buy']\n", "orders['total_profit'] = orders['profit_per_unit'] * orders['qty']\n", + "orders['commission'] = orders.eval('qty*(price+stop_loss)')*COMMISSION*0.01\n", + "orders['net_profit'] = orders['total_profit'] - orders['commission']\n", "cols = ['timestamp', 'symbol', 'buy', 'sell', 'profit_per_unit', 'total_profit']\n" ] }, @@ -204,191 +195,42 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
symbolopenhighlowcloseqtybuyselltotal_profit
1060DRREDDY2510.02632.02495.002593.402.02610.402510.0-200.80
1092TECHM768.0776.5741.50745.655.0745.65768.0111.75
1080LUPIN936.5957.9931.55936.104.0936.10936.51.60
1089TATAMOTORS271.4273.0265.25266.6015.0266.60271.472.00
1064HCLTECH1053.01061.01044.601049.154.01049.151053.015.40
\n", - "
" - ], - "text/plain": [ - " symbol open high low close qty buy sell \\\n", - "1060 DRREDDY 2510.0 2632.0 2495.00 2593.40 2.0 2610.40 2510.0 \n", - "1092 TECHM 768.0 776.5 741.50 745.65 5.0 745.65 768.0 \n", - "1080 LUPIN 936.5 957.9 931.55 936.10 4.0 936.10 936.5 \n", - "1089 TATAMOTORS 271.4 273.0 265.25 266.60 15.0 266.60 271.4 \n", - "1064 HCLTECH 1053.0 1061.0 1044.60 1049.15 4.0 1049.15 1053.0 \n", - "\n", - " total_profit \n", - "1060 -200.80 \n", - "1092 111.75 \n", - "1080 1.60 \n", - "1089 72.00 \n", - "1064 15.40 " - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "orders.tail()[['symbol', 'open', 'high', 'low', 'close', \n", - " 'qty', 'buy', 'sell', 'total_profit']]" + " 'qty', 'buy', 'sell', 'total_profit', 'net_profit']]" ] }, { - "cell_type": "code", - "execution_count": 10, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'Returns for the period = 4.11%'" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ - "total_profit = orders['total_profit'].sum()\n", - "'Returns for the period = {:.2f}%'.format((total_profit/CAPITAL)*100)" + "Profit calculated on total_profit.\n", + "You can change this to **net profit** to see the real results" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "613.7999999999997" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "orders[orders['open'] == orders['high']].total_profit.sum()" + "\n", + "total_profit = orders['total_profit'].sum()\n", + "'Returns for the period = {:.2f}%'.format((total_profit/CAPITAL)*100)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", + "from matplotlib.dates import date2num\n", "sns.set()\n", "by_day = orders.groupby('timestamp').total_profit.sum()\n", "(by_day.cumsum() + CAPITAL).plot(title = 'Portfolio by day')\n", @@ -399,480 +241,92 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
openhighlowcloselastprevclosetottrdqtytottrdvaltotaltradesretpricestop_lossqtysellbuyprofit_per_unittotal_profit
open1.0000000.9999810.9999740.9999570.9999600.999999-0.148897-0.069653-0.1503780.1746241.0000001.000000-0.3513031.0000000.9999550.892213-0.047230
high0.9999811.0000000.9999850.9999900.9999910.999978-0.149135-0.068445-0.1496670.1741660.9999810.999981-0.3537890.9999810.9999890.889674-0.050773
low0.9999740.9999851.0000000.9999900.9999900.999973-0.150328-0.069683-0.1509620.1730190.9999740.999974-0.3543940.9999740.9999890.889338-0.049820
close0.9999570.9999900.9999901.0000001.0000000.999954-0.150318-0.068979-0.1504050.1731230.9999570.999957-0.3553750.9999571.0000000.888022-0.052584
last0.9999600.9999910.9999901.0000001.0000000.999956-0.150334-0.069011-0.1504010.1732610.9999600.999960-0.3553340.9999600.9999990.888153-0.052516
prevclose0.9999990.9999780.9999730.9999540.9999561.000000-0.148804-0.069727-0.1504610.1742870.9999990.999999-0.3509770.9999990.9999520.892328-0.047054
tottrdqty-0.148897-0.149135-0.150328-0.150318-0.150334-0.1488041.0000000.8874640.8726050.081900-0.148897-0.1488970.246630-0.148897-0.150382-0.0614900.049446
tottrdval-0.069653-0.068445-0.069683-0.068979-0.069011-0.0697270.8874641.0000000.9506770.125807-0.069653-0.069653-0.081951-0.069653-0.069022-0.092186-0.118504
totaltrades-0.150378-0.149667-0.150962-0.150405-0.150401-0.1504610.8726050.9506771.0000000.172677-0.150378-0.1503780.019020-0.150378-0.150473-0.129302-0.126903
ret0.1746240.1741660.1730190.1731230.1732610.1742870.0819000.1258070.1726771.0000000.1746240.174624-0.0177580.1746240.1732570.2210060.051175
price1.0000000.9999810.9999740.9999570.9999600.999999-0.148897-0.069653-0.1503780.1746241.0000001.000000-0.3513031.0000000.9999550.892213-0.047230
stop_loss1.0000000.9999810.9999740.9999570.9999600.999999-0.148897-0.069653-0.1503780.1746241.0000001.000000-0.3513031.0000000.9999550.892213-0.047230
qty-0.351303-0.353789-0.354394-0.355375-0.355334-0.3509770.246630-0.0819510.019020-0.017758-0.351303-0.3513031.000000-0.351303-0.355410-0.1161430.184835
sell1.0000000.9999810.9999740.9999570.9999600.999999-0.148897-0.069653-0.1503780.1746241.0000001.000000-0.3513031.0000000.9999550.892213-0.047230
buy0.9999550.9999890.9999891.0000000.9999990.999952-0.150382-0.069022-0.1504730.1732570.9999550.999955-0.3554100.9999551.0000000.887912-0.052649
profit_per_unit0.8922130.8896740.8893380.8880220.8881530.892328-0.061490-0.092186-0.1293020.2210060.8922130.892213-0.1161430.8922130.8879121.0000000.217331
total_profit-0.047230-0.050773-0.049820-0.052584-0.052516-0.0470540.049446-0.118504-0.1269030.051175-0.047230-0.0472300.184835-0.047230-0.0526490.2173311.000000
\n", - "
" - ], - "text/plain": [ - " open high low close last prevclose \\\n", - "open 1.000000 0.999981 0.999974 0.999957 0.999960 0.999999 \n", - "high 0.999981 1.000000 0.999985 0.999990 0.999991 0.999978 \n", - "low 0.999974 0.999985 1.000000 0.999990 0.999990 0.999973 \n", - "close 0.999957 0.999990 0.999990 1.000000 1.000000 0.999954 \n", - "last 0.999960 0.999991 0.999990 1.000000 1.000000 0.999956 \n", - "prevclose 0.999999 0.999978 0.999973 0.999954 0.999956 1.000000 \n", - "tottrdqty -0.148897 -0.149135 -0.150328 -0.150318 -0.150334 -0.148804 \n", - "tottrdval -0.069653 -0.068445 -0.069683 -0.068979 -0.069011 -0.069727 \n", - "totaltrades -0.150378 -0.149667 -0.150962 -0.150405 -0.150401 -0.150461 \n", - "ret 0.174624 0.174166 0.173019 0.173123 0.173261 0.174287 \n", - "price 1.000000 0.999981 0.999974 0.999957 0.999960 0.999999 \n", - "stop_loss 1.000000 0.999981 0.999974 0.999957 0.999960 0.999999 \n", - "qty -0.351303 -0.353789 -0.354394 -0.355375 -0.355334 -0.350977 \n", - "sell 1.000000 0.999981 0.999974 0.999957 0.999960 0.999999 \n", - "buy 0.999955 0.999989 0.999989 1.000000 0.999999 0.999952 \n", - "profit_per_unit 0.892213 0.889674 0.889338 0.888022 0.888153 0.892328 \n", - "total_profit -0.047230 -0.050773 -0.049820 -0.052584 -0.052516 -0.047054 \n", - "\n", - " tottrdqty tottrdval totaltrades ret price \\\n", - "open -0.148897 -0.069653 -0.150378 0.174624 1.000000 \n", - "high -0.149135 -0.068445 -0.149667 0.174166 0.999981 \n", - "low -0.150328 -0.069683 -0.150962 0.173019 0.999974 \n", - "close -0.150318 -0.068979 -0.150405 0.173123 0.999957 \n", - "last -0.150334 -0.069011 -0.150401 0.173261 0.999960 \n", - "prevclose -0.148804 -0.069727 -0.150461 0.174287 0.999999 \n", - "tottrdqty 1.000000 0.887464 0.872605 0.081900 -0.148897 \n", - "tottrdval 0.887464 1.000000 0.950677 0.125807 -0.069653 \n", - "totaltrades 0.872605 0.950677 1.000000 0.172677 -0.150378 \n", - "ret 0.081900 0.125807 0.172677 1.000000 0.174624 \n", - "price -0.148897 -0.069653 -0.150378 0.174624 1.000000 \n", - "stop_loss -0.148897 -0.069653 -0.150378 0.174624 1.000000 \n", - "qty 0.246630 -0.081951 0.019020 -0.017758 -0.351303 \n", - "sell -0.148897 -0.069653 -0.150378 0.174624 1.000000 \n", - "buy -0.150382 -0.069022 -0.150473 0.173257 0.999955 \n", - "profit_per_unit -0.061490 -0.092186 -0.129302 0.221006 0.892213 \n", - "total_profit 0.049446 -0.118504 -0.126903 0.051175 -0.047230 \n", - "\n", - " stop_loss qty sell buy profit_per_unit \\\n", - "open 1.000000 -0.351303 1.000000 0.999955 0.892213 \n", - "high 0.999981 -0.353789 0.999981 0.999989 0.889674 \n", - "low 0.999974 -0.354394 0.999974 0.999989 0.889338 \n", - "close 0.999957 -0.355375 0.999957 1.000000 0.888022 \n", - "last 0.999960 -0.355334 0.999960 0.999999 0.888153 \n", - "prevclose 0.999999 -0.350977 0.999999 0.999952 0.892328 \n", - "tottrdqty -0.148897 0.246630 -0.148897 -0.150382 -0.061490 \n", - "tottrdval -0.069653 -0.081951 -0.069653 -0.069022 -0.092186 \n", - "totaltrades -0.150378 0.019020 -0.150378 -0.150473 -0.129302 \n", - "ret 0.174624 -0.017758 0.174624 0.173257 0.221006 \n", - "price 1.000000 -0.351303 1.000000 0.999955 0.892213 \n", - "stop_loss 1.000000 -0.351303 1.000000 0.999955 0.892213 \n", - "qty -0.351303 1.000000 -0.351303 -0.355410 -0.116143 \n", - "sell 1.000000 -0.351303 1.000000 0.999955 0.892213 \n", - "buy 0.999955 -0.355410 0.999955 1.000000 0.887912 \n", - "profit_per_unit 0.892213 -0.116143 0.892213 0.887912 1.000000 \n", - "total_profit -0.047230 0.184835 -0.047230 -0.052649 0.217331 \n", - "\n", - " total_profit \n", - "open -0.047230 \n", - "high -0.050773 \n", - "low -0.049820 \n", - "close -0.052584 \n", - "last -0.052516 \n", - "prevclose -0.047054 \n", - "tottrdqty 0.049446 \n", - "tottrdval -0.118504 \n", - "totaltrades -0.126903 \n", - "ret 0.051175 \n", - "price -0.047230 \n", - "stop_loss -0.047230 \n", - "qty 0.184835 \n", - "sell -0.047230 \n", - "buy -0.052649 \n", - "profit_per_unit 0.217331 \n", - "total_profit 1.000000 " - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ + "# Correlation matrix\n", + "# This is useful to find related factors\n", "orders.corr()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Profit by date\n", + "# Add any columns if you like in the cols list\n", + "cols = ['total_profit', 'net_profit']\n", + "orders.groupby('timestamp')[cols].sum().tail()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Best and worst results\n", + "# Change n for the required number of days\n", + "n = 5\n", + "\n", + "print('Best results')\n", + "print(orders.groupby('timestamp')['total_profit'].sum().sort_values().tail(n))\n", + "\n", + "print('Worst results')\n", + "print(orders.groupby('timestamp')['total_profit'].sum().sort_values().head(n))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Pyfolio results\n", + "\n", + "Your backtest period must contain 2 years (dec 2017 - jan 2018 is also fine) for pyfolio to work properly.\n", + "\n", + "I haven't figured out the exact error so far and correcting it requires way too many hacks. So its better to stick with it for now" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use this hack if pyfolio doesn't import for you\n", + "\n", + "import pandas\n", + "pandas.core.common.is_list_like = pd.api.types.is_list_like\n", + "import pyfolio as pf\n", + "pf.plotting.plot_rolling_fama_french = pf.plot_returns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change to **net_profit** to get actual results." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "returns = (orders.groupby('timestamp')['total_profit'].sum())/CAPITAL\n", + "returns.index = returns.index.tz_localize('UTC')\n", + "\n", + "# Replace this with NIFTY\n", + "import numpy as np\n", + "bench = pd.Series(np.random.randn(len(returns))*0.01,\n", + " index=returns.index)\n", + "pf.create_interesting_times_tear_sheet(returns, benchmark_rets=bench)\n", + "pf.create_returns_tear_sheet(returns, benchmark_rets=bench)" + ] } ], "metadata": { @@ -891,7 +345,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.5" + "version": "3.6.6" } }, "nbformat": 4, diff --git a/tradingsystem/System.ipynb b/tradingsystem/System.ipynb index 52d3088..2479eff 100644 --- a/tradingsystem/System.ipynb +++ b/tradingsystem/System.ipynb @@ -49,10 +49,8 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ "### Don't change the below cell" ] @@ -92,13 +90,12 @@ "trading_capital = CAPITAL * LEVERAGE\n", "orders = pd.read_excel('output.xlsx')\n", "num_stock = len(orders)\n", - "orders['price'] = orders['OPENPRICE']\n", - "orders['qty'] = (trading_capital/num_stock/orders['price']).round()\n", + "orders['trigger_price'] = orders['OPENPRICE']\n", + "orders['qty'] = (trading_capital/num_stock/orders['trigger_price']).round()\n", "orders['order'] = 'SELL'\n", - "\n", - "orders.to_csv('orders.csv', index=False)\n", - "print('Orders file created')\n", - "orders" + "orders['price'] = orders['trigger_price'] - 0.05\n", + "orders['stop_loss'] = (orders['price'] * (1 + STOP_LOSS * 0.01)).round(2)\n", + "orders.to_csv('orders.csv', index=False)" ] }, { @@ -123,19 +120,21 @@ "*Thanks @vjay for providing the necessary support*\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## PARAMETERS to change for order execution" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "trading_capital = CAPITAL * LEVERAGE\n", - "orders = pd.read_excel('output.xlsx')\n", - "num_stock = len(orders)\n", - "orders['trigger_price'] = orders['OPENPRICE']\n", - "orders['qty'] = (trading_capital/num_stock/orders['trigger_price']).round()\n", - "orders['order'] = 'SELL'\n", - "orders['price'] = orders['trigger_price'] - 0.05" + "# Change your account id here\n", + "ACCOUNTID = 'XXXXXX' " ] }, { @@ -165,7 +164,7 @@ " 'ExpiryDate': 'NA',\n", " 'LTP': 0,\n", " 'Disclosed Qty': 0,\n", - " 'AccountId': 'DV0018',\n", + " 'AccountId': ACCOUNTID,\n", " 'Pro/Cli': 'CLI',\n", " 'Validity': 'DAY',\n", " 'P Type': 'MIS',\n", @@ -202,23 +201,22 @@ "exit_orders = orders.copy()\n", "exit_orders['order'] = 'BUY'\n", "exit_orders['price'] = 0\n", - "exit_orders['trigger_price'] = list(stop_loss(orders['price'], 3, order='S').round(2))\n", + "exit_orders['trigger_price'] = list(stop_loss(orders['price'], STOP_LOSS, order='S').round(2))\n", "columns.update({'Order Type': 'SL-M'})\n", "exit = create_orders(exit_orders, rename=rename, **columns)\n", "\n", "# File generation\n", - "entry.append(exit)[cols].to_csv('orders_to_place.csv', \n", + "entry.append(exit, sort=False)[cols].to_csv('orders_to_place.csv', \n", " index=False, header=False)\n", + "print('File generated')\n", "\n", "# If you want header change header to True\n", "# If you want to export as excel use the to_excel function" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ "### Run the below cell to evaluate peformance" ] diff --git a/tradingsystem/SystemNew.ipynb b/tradingsystem/SystemNew.ipynb index 017de43..393d5c4 100644 --- a/tradingsystem/SystemNew.ipynb +++ b/tradingsystem/SystemNew.ipynb @@ -7,7 +7,7 @@ "## This is the updated system\n", "1. Fetch data from NSE\n", "2. Automatically generate prices and stop loss\n", - "3. " + "3. Option to diversify stocks" ] }, { @@ -17,11 +17,10 @@ "## Instructions\n", "1. See instructions for each cell\n", "2. You need to change only the PARAMETERS, nothing else\n", - "3. You need to have 2 bhav copy files, one to generate orders and the next to evaluate performance\n", - "4. Based on the previous day orders, **results.xlsx** file is generated. You need to fill in the current day's open price and run the cells below it to generate orders. This would generate **orders.csv** file\n", - "5. At the end of the day, you need to download the bhav copy results to evaluate performance. This would generate a **peformance.csv** file\n", - "\n", - "Save all these files at the end of the day in a new folder. We would automate this process also soon" + "3. Store all your data in data folder\n", + "4. All the orders you generate go into the orders folder\n", + "5. Orders for the present day are created with the filename **orders_to_place.csv** and stored in the current directory\n", + "6. If you need to diversify among sectors, set the **DIVERSIFY** parameter to **True**" ] }, { @@ -35,611 +34,356 @@ "import os" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameters that could be changed" + ] + }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "%load_ext autoreload" + "UNIVERSE = 'NIFTY50' # Universe to be searched\n", + "ORDER_FILENAME = 'data/cm23OCT2018bhav.csv.zip'\n", + "STOP_LOSS = 3 # Stop loss for the order\n", + "NUM_STOCKS = 5 # Number of stocks to sell\n", + "CAPITAL = 20000\n", + "LEVERAGE = 1\n", + "ORDERFILE_PREFIX = 'orders_' # Prefix file name to store\n", + "DIVERSIFY = False # whether to diversify data among sectors" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SYMBOLPctChangeOpenPrice
0COALINDIA1.14282.80
1GAIL1.13381.95
2INFRATEL-0.16275.25
3NTPC-0.09169.05
4HINDPETRO-0.02246.60
5AXISBANK-0.02651.65
6LUPIN0.98953.65
7SBIN0.88287.35
8SUNPHARMA0.78643.00
9TECHM0.75772.00
10YESBANK0.73326.00
11ZEEL0.69476.00
12INFY0.69735.90
13VEDL0.67225.00
14GRASIM0.631022.50
15M&M0.60943.00
16WIPRO0.60326.95
17UPL0.60707.50
18DRREDDY0.572578.45
19TATAMOTORS0.56277.25
20ADANIPORTS0.52373.90
21BPCL0.49345.80
22HEROMOTOCO0.483294.00
23HINDALCO0.47236.80
24TCS0.402089.00
25LT0.361341.55
26HDFC0.341890.00
27MARUTI0.338668.00
28CIPLA0.31670.10
29KOTAKBANK0.301227.00
30TITAN0.29860.00
31TATASTEEL0.28615.35
32INDUSINDBK0.271834.10
33HDFCBANK0.252046.30
34RELIANCE0.251259.00
35ICICIBANK0.24333.70
36BAJAJ-AUTO0.222875.00
37EICHERMOT0.2028680.00
38BAJFINANCE0.202621.00
39HINDUNILVR0.171613.00
40ASIANPAINT0.151295.00
41HCLTECH0.121090.00
42BAJAJFINSV0.066351.10
43IBULHSGFIN0.061162.00
44POWERGRID0.05193.05
45BHARTIARTL0.03388.50
46ONGC0.03168.70
47ITC0.03306.65
48IOC0.03151.10
49ULTRACEMCO0.004154.75
\n", - "
" - ], - "text/plain": [ - " SYMBOL PctChange OpenPrice\n", - "0 COALINDIA 1.14 282.80\n", - "1 GAIL 1.13 381.95\n", - "2 INFRATEL -0.16 275.25\n", - "3 NTPC -0.09 169.05\n", - "4 HINDPETRO -0.02 246.60\n", - "5 AXISBANK -0.02 651.65\n", - "6 LUPIN 0.98 953.65\n", - "7 SBIN 0.88 287.35\n", - "8 SUNPHARMA 0.78 643.00\n", - "9 TECHM 0.75 772.00\n", - "10 YESBANK 0.73 326.00\n", - "11 ZEEL 0.69 476.00\n", - "12 INFY 0.69 735.90\n", - "13 VEDL 0.67 225.00\n", - "14 GRASIM 0.63 1022.50\n", - "15 M&M 0.60 943.00\n", - "16 WIPRO 0.60 326.95\n", - "17 UPL 0.60 707.50\n", - "18 DRREDDY 0.57 2578.45\n", - "19 TATAMOTORS 0.56 277.25\n", - "20 ADANIPORTS 0.52 373.90\n", - "21 BPCL 0.49 345.80\n", - "22 HEROMOTOCO 0.48 3294.00\n", - "23 HINDALCO 0.47 236.80\n", - "24 TCS 0.40 2089.00\n", - "25 LT 0.36 1341.55\n", - "26 HDFC 0.34 1890.00\n", - "27 MARUTI 0.33 8668.00\n", - "28 CIPLA 0.31 670.10\n", - "29 KOTAKBANK 0.30 1227.00\n", - "30 TITAN 0.29 860.00\n", - "31 TATASTEEL 0.28 615.35\n", - "32 INDUSINDBK 0.27 1834.10\n", - "33 HDFCBANK 0.25 2046.30\n", - "34 RELIANCE 0.25 1259.00\n", - "35 ICICIBANK 0.24 333.70\n", - "36 BAJAJ-AUTO 0.22 2875.00\n", - "37 EICHERMOT 0.20 28680.00\n", - "38 BAJFINANCE 0.20 2621.00\n", - "39 HINDUNILVR 0.17 1613.00\n", - "40 ASIANPAINT 0.15 1295.00\n", - "41 HCLTECH 0.12 1090.00\n", - "42 BAJAJFINSV 0.06 6351.10\n", - "43 IBULHSGFIN 0.06 1162.00\n", - "44 POWERGRID 0.05 193.05\n", - "45 BHARTIARTL 0.03 388.50\n", - "46 ONGC 0.03 168.70\n", - "47 ITC 0.03 306.65\n", - "48 IOC 0.03 151.10\n", - "49 ULTRACEMCO 0.00 4154.75" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "%autoreload\n", "from utils import *\n", - "fetch_preopen_data()" + "preopen = fetch_preopen_data()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "### Don't change the below cell" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Parameters that could be changed" + "## Preparing the dataframe" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "UNIVERSE = 'NIFTY50' # Universe to be searched\n", - "STOP_LOSS = 3 # Stop loss for the order\n", - "NUM_STOCKS = 5 # Number of stocks to sell\n", - "CAPITAL = 20000\n", - "LEVERAGE = 1" + "eod = pd.read_csv(ORDER_FILENAME, parse_dates=['TIMESTAMP'],\n", + " usecols=range(13))\n", + "symbols = pd.read_excel('universe.xlsx', sheet_name=UNIVERSE, header=None).values.ravel()\n", + "sectors = pd.read_csv('sectors.csv')\n", + "df = eod[eod['SYMBOL'].isin(symbols)]\n", + "df = df[df['SERIES'] == \"EQ\"].reset_index(drop=True)\n", + "df = df.merge(sectors)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Trading logic\n", + "\n", + "There is where all your logic goes.\n", + "At present, we short the top n stocks the previous day" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "### Don't change the below cell" + "# Don't change this function\n", + "def diversify(frame, n=5):\n", + " \"\"\"\n", + " Diversify stocks among sectors\n", + " frame\n", + " dataframe\n", + " n\n", + " number of stocks\n", + " \"\"\"\n", + " industry = set()\n", + " stocks = []\n", + " for k,v in frame.iterrows():\n", + " if v.at['Industry'] not in industry:\n", + " industry.add(v.at['Industry'])\n", + " stocks.append(v)\n", + " if len(stocks) == n:\n", + " break\n", + " f = pd.DataFrame(stocks)\n", + " if len(f) == 0:\n", + " return pd.DataFrame()\n", + " else:\n", + " return f " ] }, { "cell_type": "code", - "execution_count": 3, - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "outputs": [ - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'cm29AUG2018bhav.csv.zip'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m orders = pd.read_csv(ORDER_FILENAME, parse_dates=['TIMESTAMP'],\n\u001b[0;32m----> 2\u001b[0;31m usecols=range(13))\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0msymbols\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mpd\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mread_excel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'universe.xlsx'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msheet_name\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mUNIVERSE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mheader\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mravel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0morders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0morders\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'SYMBOL'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0misin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msymbols\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'SERIES'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"EQ\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdrop\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/pandas/io/parsers.py\u001b[0m in \u001b[0;36mparser_f\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, squeeze, prefix, mangle_dupe_cols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, dayfirst, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, escapechar, comment, encoding, dialect, tupleize_cols, error_bad_lines, warn_bad_lines, skipfooter, doublequote, delim_whitespace, low_memory, memory_map, float_precision)\u001b[0m\n\u001b[1;32m 676\u001b[0m skip_blank_lines=skip_blank_lines)\n\u001b[1;32m 677\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 678\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_read\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 679\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 680\u001b[0m \u001b[0mparser_f\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__name__\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/pandas/io/parsers.py\u001b[0m in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 438\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 439\u001b[0m \u001b[0;31m# Create the parser.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 440\u001b[0;31m \u001b[0mparser\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mTextFileReader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfilepath_or_buffer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 441\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 442\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mchunksize\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0miterator\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/pandas/io/parsers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, f, engine, **kwds)\u001b[0m\n\u001b[1;32m 785\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'has_index_names'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'has_index_names'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 786\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 787\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_make_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mengine\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 788\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 789\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/pandas/io/parsers.py\u001b[0m in \u001b[0;36m_make_engine\u001b[0;34m(self, engine)\u001b[0m\n\u001b[1;32m 1012\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_make_engine\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mengine\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'c'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1013\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mengine\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'c'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1014\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mCParserWrapper\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0moptions\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1015\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1016\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mengine\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'python'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/site-packages/pandas/io/parsers.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, src, **kwds)\u001b[0m\n\u001b[1;32m 1706\u001b[0m \u001b[0mkwds\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'usecols'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0musecols\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1707\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1708\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_reader\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mparsers\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mTextReader\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msrc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwds\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1709\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1710\u001b[0m \u001b[0mpassed_names\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnames\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32mpandas/_libs/parsers.pyx\u001b[0m in \u001b[0;36mpandas._libs.parsers.TextReader.__cinit__\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/parsers.pyx\u001b[0m in \u001b[0;36mpandas._libs.parsers.TextReader._setup_parser_source\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32m~/anaconda3/lib/python3.6/zipfile.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, file, mode, compression, allowZip64)\u001b[0m\n\u001b[1;32m 1088\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1089\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1090\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfp\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mio\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfile\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilemode\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1091\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mOSError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1092\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mfilemode\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mmodeDict\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'cm29AUG2018bhav.csv.zip'" - ] - } - ], + "execution_count": 7, + "metadata": {}, + "outputs": [], "source": [ - "orders = pd.read_csv(ORDER_FILENAME, parse_dates=['TIMESTAMP'],\n", - " usecols=range(13))\n", - "symbols = pd.read_excel('universe.xlsx', sheet_name=UNIVERSE, header=None).values.ravel()\n", - "df = orders[orders['SYMBOL'].isin(symbols)]\n", - "df = df[df['SERIES'] == \"EQ\"].reset_index(drop=True)\n", "df['RET'] = (df['CLOSE']/df['PREVCLOSE']) - 1\n", - "result = df.sort_values(by='RET', ascending = False).iloc[:NUM_STOCKS]\n", - "result['OPENPRICE'] = 0\n", - "result[['TIMESTAMP', 'SYMBOL', 'OPENPRICE']].to_excel('output.xlsx', index=False)\n", - "print('Update OPENPRICE in the output.xlsx file')\n", - "result[['TIMESTAMP', 'SYMBOL', 'OPENPRICE']]" + "if DIVERSIFY:\n", + " result = diversify(df.sort_values(by='RET', ascending=False), NUM_STOCKS)\n", + "else:\n", + " result = df.sort_values(by='RET', ascending = False).iloc[:NUM_STOCKS]" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "trading_capital = CAPITAL * LEVERAGE\n", + "orders = result.merge(preopen, on='SYMBOL')\n", + "num_stock = len(orders)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Update OPEN PRICE in output.xlsx file and run the below cell" + "## Pricing logic goes here" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# I prefer a constant percentage change instead of value\n", + "# If you prefer it, make this raw and use the below cell\n", + "\n", + "orders['trigger_price'] = (orders['OpenPrice'] - 0.05).round(2)\n", + "orders['price'] = (orders['trigger_price'] - 0.05).round(2)" + ] + }, + { + "cell_type": "raw", + "metadata": {}, + "source": [ + "# Price calculated at a fixed percentage from open price\n", + "\n", + "orders['trigger_price'] = orders['OpenPrice'] * 0.9985\n", + "orders['price'] = orders['trigger_price'] - 0.05" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Stop loss and quantity automatically generated\n", + "\n", + "orders['stop_loss'] = (orders['price'] * (1 + STOP_LOSS * 0.01)).apply(tick).round(2)\n", + "orders['qty'] = (trading_capital/num_stock/orders['price']).astype(int)\n", + "orders['order'] = 'SELL'\n", + "import datetime\n", + "filename = ORDERFILE_PREFIX + datetime.datetime.today().strftime('%Y-%m-%d') + '.csv'\n", + "orders.to_csv('orders/' + filename, index=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Use the below cells to generate orders for your broker\n", + "#### I have included code for **NEST**\n", + "\n", + "Most brokers and software provide an option to place basket orders. So we are going to create a basket order from our orders. We would be using the ``create_order`` function from ``utils.py`` file.\n", + "\n", + "To do this for your specific broker, do the following steps\n", + "\n", + "1. Know the format of your broker; you can do this by placing a basket order and exporting it\n", + "2. The format would usually have a list of columns to be filled up. We need to fill all the columns to import our order.\n", + "3. We separate the columns into columns that are already in our dataframe and columns to be included\n", + "4. We prepare a list of matching columns and rename them\n", + "5. For new columns, we create a python dictionary with keys as column names and values as the value for the column (we assume that these columns have a single value)\n", + "\n", + "All this has been done for NEST.\n", + "\n", + "*Thanks @vjay for providing the necessary support*\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Parameters for order generation\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "ACCOUNTID = 'XXXXXX' # Your accountId with broker" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# List of columns to be included in the output\n", + "\n", + "cols = [\n", + " 'Segment', 'InstrumentName', 'Symbol', 'Option Type', 'Strike Price',\n", + " 'ExpiryDate', 'Price', 'Qty', 'LTP', 'Buy/Sell', 'Order Type',\n", + " 'TriggerPrice', 'Pro/Cli', 'P Type', 'Validity', 'AccountId',\n", + " 'Validity Date', 'Remarks', 'Participant code', 'Validity Time',\n", + " 'Market Proc' \n", + "]\n", + "\n", + "# These columns are common for all orders - columns with a single name\n", + "columns = {\n", + " 'Segment': 'NSE',\n", + " 'InstrumentName': 'EQ',\n", + " 'Option Type': 'NA',\n", + " 'Strike Price': 'NA',\n", + " 'ExpiryDate': 'NA',\n", + " 'LTP': 0,\n", + " 'Disclosed Qty': 0,\n", + " 'AccountId': ACCOUNTID,\n", + " 'Pro/Cli': 'CLI',\n", + " 'Validity': 'DAY',\n", + " 'P Type': 'MIS',\n", + " 'Remarks': '',\n", + " 'Validity Date': 'NA',\n", + " 'Participant code': '',\n", + " 'Validity Time': 'NA',\n", + " 'Market Proc': 'NA',\n", + " 'Order Type': 'SL'\n", + "}\n", + "\n", + "# These are columns to be renamed\n", + "rename = {\n", + " 'order': 'Buy/Sell',\n", + " 'price': 'Price',\n", + " 'qty': 'Qty',\n", + " 'trigger_price': 'TriggerPrice',\n", + " 'price': 'Price' ,\n", + " 'SYMBOL': 'Symbol'\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Orders file created\n" + "File generated\n" ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TIMESTAMPSYMBOLOPENPRICEpricestop_lossqty
02018-08-24VEDL225.95225.95232.7318.0
12018-08-24ONGC175.45175.45180.7123.0
22018-08-24GRASIM1063.101063.101094.994.0
32018-08-24AXISBANK643.00643.00662.296.0
42018-08-24ZEEL517.00517.00532.518.0
\n", - "
" - ], - "text/plain": [ - " TIMESTAMP SYMBOL OPENPRICE price stop_loss qty\n", - "0 2018-08-24 VEDL 225.95 225.95 232.73 18.0\n", - "1 2018-08-24 ONGC 175.45 175.45 180.71 23.0\n", - "2 2018-08-24 GRASIM 1063.10 1063.10 1094.99 4.0\n", - "3 2018-08-24 AXISBANK 643.00 643.00 662.29 6.0\n", - "4 2018-08-24 ZEEL 517.00 517.00 532.51 8.0" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" } ], "source": [ - "trading_capital = CAPITAL * LEVERAGE\n", - "orders = pd.read_excel('output.xlsx')\n", - "num_stock = len(orders)\n", - "orders['price'] = orders['OPENPRICE']\n", - "orders['stop_loss'] = (orders['price'] * 1.03).round(2)\n", - "orders['qty'] = (trading_capital/num_stock/orders['price']).round()\n", - "orders.to_csv('orders.csv', index=False)\n", - "print('Orders file created')\n", - "orders" + "# Generating orders in the required format\n", + "entry_orders = orders.copy()\n", + "entry = create_orders(entry_orders, rename=rename, **columns)\n", + "\n", + "# Exit orders order type and price to be changed\n", + "exit_orders = orders.copy()\n", + "exit_orders['order'] = 'BUY'\n", + "exit_orders['price'] = 0\n", + "exit_orders['trigger_price'] = stop_loss(orders['price'], 3, order='S').round(2)\n", + "columns.update({'Order Type': 'SL-M'})\n", + "exit = create_orders(exit_orders, rename=rename, **columns)\n", + "\n", + "# File generation\n", + "entry.append(exit, sort=False)[cols].to_csv('orders_to_place.csv', \n", + " index=False, header=False)\n", + "\n", + "print('File generated')\n", + "\n", + "# If you want header change header to True\n", + "# If you want to export as excel use the to_excel function" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Order generation for Kite Zerodha\n", + "\n", + "1. Sign up for a zerodha publisher api key [here](https://kite.trade/)\n", + "2. Update the API key in the below cell\n", + "3. Run the below cells. It would create an html file **zerodha_order.html** in your present working directory.\n", + "4. Open the HTML file and click the submit button to log into zerodha and place your orders.\n", + "\n", + "See the updated at time to make sure that this is the latest generated order." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "APIKEY = 'xxxxxxxxxxxxxxxx'" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# List of columns to be included in the output\n", + "\n", + "cols = [\n", + " 'tradingsymbol', 'exchange', 'transaction_type', 'order_type',\n", + " 'quantity', 'product', 'validity', 'price', 'trigger_price'\n", + "]\n", + "\n", + "# These columns are common for all orders - columns with a single name\n", + "columns = {\n", + " 'exchange': 'NSE',\n", + " 'product': 'MIS',\n", + " 'validity': 'DAY',\n", + " 'order_type': 'SL'\n", + "}\n", + "\n", + "# These are columns to be renamed\n", + "rename = {\n", + " 'order': 'transaction_type',\n", + " 'price': 'Price',\n", + " 'qty': 'quantity',\n", + " 'trigger_price': 'trigger_price',\n", + " 'price': 'price' ,\n", + " 'SYMBOL': 'tradingsymbol'\n", + "}" ] }, { @@ -648,130 +392,45 @@ "metadata": {}, "outputs": [], "source": [ - "### Run the below cell to evaluate peformance" + "# Generating orders in the required format\n", + "entry_orders = orders.copy()\n", + "entry = create_orders(entry_orders, rename=rename, **columns)\n", + "\n", + "# Exit orders order type and price to be changed\n", + "exit_orders = orders.copy()\n", + "exit_orders['order'] = 'BUY'\n", + "exit_orders['price'] = 0\n", + "exit_orders['trigger_price'] = stop_loss(orders['price'], 3, order='S').round(2)\n", + "columns.update({'order_type': 'SL-M'})\n", + "exit = create_orders(exit_orders, rename=rename, **columns)\n", + "trades = entry.append(exit, sort=False)[cols].to_dict(orient='records')" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TIMESTAMPSYMBOLBUYSELLprofit_per_unittotal_profit
02018-08-27VEDL225.50225.950.458.1
12018-08-27ONGC176.05175.45-0.60-13.8
22018-08-27GRASIM1078.451063.10-15.35-61.4
32018-08-27AXISBANK650.20643.00-7.20-43.2
42018-08-27ZEEL511.20517.005.8046.4
\n", - "
" - ], - "text/plain": [ - " TIMESTAMP SYMBOL BUY SELL profit_per_unit total_profit\n", - "0 2018-08-27 VEDL 225.50 225.95 0.45 8.1\n", - "1 2018-08-27 ONGC 176.05 175.45 -0.60 -13.8\n", - "2 2018-08-27 GRASIM 1078.45 1063.10 -15.35 -61.4\n", - "3 2018-08-27 AXISBANK 650.20 643.00 -7.20 -43.2\n", - "4 2018-08-27 ZEEL 511.20 517.00 5.80 46.4" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "Zerodha order file generated\n" + ] } ], "source": [ - "def isPrice(price, high, low):\n", - " if price >= low and price <=high:\n", - " return True\n", - " else:\n", - " False\n", + "import json\n", + "from jinja2 import Environment, FileSystemLoader\n", + "env = Environment(loader=FileSystemLoader('.'))\n", + "template = env.get_template('template.html')\n", + "output_from_parsed_template = template.render(api_key = APIKEY,\n", + " orders=json.dumps(trades), \n", + " date=str(datetime.datetime.now()))\n", "\n", - "orders = pd.read_csv('orders.csv', index_col='TIMESTAMP', parse_dates=True)\n", - "end_of_day = pd.read_csv(RESULT_FILENAME, parse_dates=['TIMESTAMP'],\n", - " usecols=range(13))\n", - "end_of_day = end_of_day[end_of_day['SERIES'] == \"EQ\"]\n", - "orders = orders.merge(end_of_day)\n", - "orders['SELL'] = [price if isPrice(price, high, low) else close for\n", - " price, high, low, close in \n", - " zip(orders['price'], orders['HIGH'], orders['LOW'], orders[REF_PRICE])]\n", - "orders['BUY'] = [price if isPrice(price, high, low) else close for\n", - " price, high, low, close in \n", - " zip(orders['stop_loss'], orders['HIGH'], orders['LOW'], orders[REF_PRICE])]\n", - "orders['profit_per_unit'] = orders['SELL'] - orders['BUY']\n", - "orders['total_profit'] = orders['profit_per_unit'] * orders['qty']\n", - "cols = ['TIMESTAMP', 'SYMBOL', 'BUY', 'SELL', 'profit_per_unit', 'total_profit']\n", - "orders.to_csv('performance.csv', index=False)\n", - "orders[cols]" + "with open('zerodha_order.html', 'w') as f:\n", + " f.write(output_from_parsed_template)\n", + " print('Zerodha order file generated')" ] } ], diff --git a/tradingsystem/linux_runner.sh b/tradingsystem/linux_runner.sh new file mode 100755 index 0000000..ddcc6a6 --- /dev/null +++ b/tradingsystem/linux_runner.sh @@ -0,0 +1,7 @@ +#!/bin/sh + +# Assuming anaconda is installed on PATH +# run this from your tradingsystem directory + +export PATH=$HOME/anaconda3/bin:$PATH +python trading_system.py diff --git a/tradingsystem/orders/orders_2018-09-15.csv b/tradingsystem/orders/orders_2018-09-15.csv new file mode 100644 index 0000000..862ad64 --- /dev/null +++ b/tradingsystem/orders/orders_2018-09-15.csv @@ -0,0 +1,6 @@ +SYMBOL,SERIES,OPEN,HIGH,LOW,CLOSE,LAST,PREVCLOSE,TOTTRDQTY,TOTTRDVAL,TIMESTAMP,TOTALTRADES,ISIN,RET,PctChange,OpenPrice,trigger_price,price,stop_loss,qty +COALINDIA,EQ,282.8,288.0,275.8,283.1,284.4,279.6,4990180,1399199906.35,2018-09-11,59416,INE522F01014,0.012517882689556448,0.52,283.0,282.95,282.9,291.40000000000003,14.0 +M&M,EQ,943.0,961.0,936.3,943.15,947.0,937.35,3909701,3713736740.1,2018-09-11,88297,INE101A01026,0.006187656691737375,0.33,941.2,941.1500000000001,941.1000000000001,969.35,4.0 +INFY,EQ,735.9,744.75,732.0,734.3,733.7,730.85,6963561,5143145755.5,2018-09-11,137146,INE009A01021,0.004720530888691066,-0.13,741.9,741.85,741.8000000000001,764.0500000000001,5.0 +ASIANPAINT,EQ,1295.0,1313.3,1286.7,1297.85,1295.5,1293.1,1676544,2184856922.15,2018-09-11,52951,INE021A01026,0.0036733431289150964,0.6,1298.8,1298.75,1298.7,1337.65,3.0 +NTPC,EQ,169.05,171.75,168.75,169.75,170.1,169.2,8091175,1376813726.15,2018-09-11,47967,INE733E01010,0.003250591016548565,0.24,170.4,170.35,170.29999999999998,175.4,23.0 diff --git a/tradingsystem/orders/orders_2018-09-17.csv b/tradingsystem/orders/orders_2018-09-17.csv new file mode 100644 index 0000000..832676d --- /dev/null +++ b/tradingsystem/orders/orders_2018-09-17.csv @@ -0,0 +1,6 @@ +SYMBOL,SERIES,OPEN,HIGH,LOW,CLOSE,LAST,PREVCLOSE,TOTTRDQTY,TOTTRDVAL,TIMESTAMP,TOTALTRADES,ISIN,RET,PctChange,OpenPrice,trigger_price,price,stop_loss,qty +IBULHSGFIN,EQ,1153.65,1234.75,1152.0,1227.1,1225.0,1145.1,3623596,4372549715.0,2018-09-14,101918,INE148I01020,0.0716094664221465,-0.42,1222.0,1221.95,1221.9,1258.5500000000002,3.0 +BPCL,EQ,340.15,356.6,340.0,354.5,355.25,334.15,9330736,3260699196.1,2018-09-14,108286,INE029A01011,0.06090079305701046,-0.41,353.05,353.0,352.95,363.55,11.0 +VEDL,EQ,228.8,236.45,226.05,235.6,235.0,223.6,17674079,4097577697.75,2018-09-14,122443,INE205A01025,0.05366726296958846,-0.06,235.45,235.39999999999998,235.34999999999997,242.4,17.0 +HINDPETRO,EQ,245.0,254.4,244.5,252.65,253.85,240.4,7030739,1754195322.5,2018-09-14,80801,INE094A01015,0.05095673876871887,-1.01,250.1,250.04999999999998,249.99999999999997,257.5,16.0 +UPL,EQ,710.0,738.9,709.1,736.75,738.0,703.65,3848531,2810895436.35,2018-09-14,75530,INE628A01036,0.047040432032970925,-0.25,734.9,734.85,734.8000000000001,756.85,5.0 diff --git a/tradingsystem/orders_to_place.csv b/tradingsystem/orders_to_place.csv new file mode 100644 index 0000000..4bd8f20 --- /dev/null +++ b/tradingsystem/orders_to_place.csv @@ -0,0 +1,10 @@ +NSE,EQ,HINDPETRO,NA,NA,NA,226.8,17,0,SELL,SL,226.85,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,IBULHSGFIN,NA,NA,NA,752.6,5,0,SELL,SL,752.65,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,HDFC,NA,NA,NA,1714.9,2,0,SELL,SL,1714.95,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,INDUSINDBK,NA,NA,NA,1489.9,2,0,SELL,SL,1489.95,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,BAJAJ-AUTO,NA,NA,NA,2614.9,1,0,SELL,SL,2614.95,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,HINDPETRO,NA,NA,NA,0.0,17,0,BUY,SL-M,233.6,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,IBULHSGFIN,NA,NA,NA,0.0,5,0,BUY,SL-M,775.2,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,HDFC,NA,NA,NA,0.0,2,0,BUY,SL-M,1766.35,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,INDUSINDBK,NA,NA,NA,0.0,2,0,BUY,SL-M,1534.6,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA +NSE,EQ,BAJAJ-AUTO,NA,NA,NA,0.0,1,0,BUY,SL-M,2693.35,CLI,MIS,DAY,XXXXXX,NA,,,NA,NA diff --git a/tradingsystem/sectors.csv b/tradingsystem/sectors.csv new file mode 100644 index 0000000..9222d86 --- /dev/null +++ b/tradingsystem/sectors.csv @@ -0,0 +1,502 @@ +SYMBOL,Industry +3MINDIA,SERVICES +8KMILES,IT +ABB,INDUSTRIAL MANUFACTURING +ACC,CEMENT & CEMENT PRODUCTS +AIAENG,INDUSTRIAL MANUFACTURING +APLAPOLLO,METALS +AUBANK,FINANCIAL SERVICES +AARTIIND,CHEMICALS +ADANIPORTS,SERVICES +ADANIPOWER,ENERGY +ADANITRANS,ENERGY +ABCAPITAL,FINANCIAL SERVICES +ABFRL,CONSUMER GOODS +ADVENZYMES,CONSUMER GOODS +AEGISCHEM,ENERGY +AJANTPHARM,PHARMA +AKZOINDIA,CONSUMER GOODS +APLLTD,PHARMA +ALKEM,PHARMA +ALBK,FINANCIAL SERVICES +ALLCARGO,SERVICES +AMARAJABAT,AUTOMOBILE +AMBUJACEM,CEMENT & CEMENT PRODUCTS +ANDHRABANK,FINANCIAL SERVICES +APOLLOHOSP,HEALTHCARE SERVICES +APOLLOTYRE,AUTOMOBILE +ASHOKLEY,AUTOMOBILE +ASHOKA,CONSTRUCTION +ASIANPAINT,CONSUMER GOODS +ASTERDM,HEALTHCARE SERVICES +ASTRAL,INDUSTRIAL MANUFACTURING +ATUL,CHEMICALS +AUROPHARMA,PHARMA +AVANTIFEED,CONSUMER GOODS +DMART,CONSUMER GOODS +AXISBANK,FINANCIAL SERVICES +BASF,CHEMICALS +BEML,INDUSTRIAL MANUFACTURING +BSE,FINANCIAL SERVICES +BAJAJ-AUTO,AUTOMOBILE +BAJAJCORP,CONSUMER GOODS +BAJAJELEC,CONSUMER GOODS +BAJFINANCE,FINANCIAL SERVICES +BAJAJFINSV,FINANCIAL SERVICES +BAJAJHLDNG,FINANCIAL SERVICES +BALKRISIND,AUTOMOBILE +BALMLAWRIE,SERVICES +BALRAMCHIN,CONSUMER GOODS +BANDHANBNK,FINANCIAL SERVICES +BANKBARODA,FINANCIAL SERVICES +BANKINDIA,FINANCIAL SERVICES +BATAINDIA,CONSUMER GOODS +BERGEPAINT,CONSUMER GOODS +BDL,INDUSTRIAL MANUFACTURING +BEL,INDUSTRIAL MANUFACTURING +BHARATFIN,FINANCIAL SERVICES +BHARATFORG,INDUSTRIAL MANUFACTURING +BHEL,INDUSTRIAL MANUFACTURING +BPCL,ENERGY +BHARTIARTL,TELECOM +INFRATEL,TELECOM +BIOCON,PHARMA +BIRLACORPN,CEMENT & CEMENT PRODUCTS +BLISSGVS,PHARMA +BLUEDART,SERVICES +BLUESTARCO,CONSUMER GOODS +BBTC,CONSUMER GOODS +BOMDYEING,TEXTILES +BOSCHLTD,AUTOMOBILE +BRIGADE,CONSTRUCTION +BRITANNIA,CONSUMER GOODS +CARERATING,FINANCIAL SERVICES +CCL,CONSUMER GOODS +CGPOWER,INDUSTRIAL MANUFACTURING +CRISIL,FINANCIAL SERVICES +CADILAHC,PHARMA +CANFINHOME,FINANCIAL SERVICES +CANBK,FINANCIAL SERVICES +CAPF,FINANCIAL SERVICES +CAPLIPOINT,PHARMA +CARBORUNIV,INDUSTRIAL MANUFACTURING +CASTROLIND,ENERGY +CEATLTD,AUTOMOBILE +CENTRALBK,FINANCIAL SERVICES +CDSL,FINANCIAL SERVICES +CENTURYPLY,CONSUMER GOODS +CENTURYTEX,CEMENT & CEMENT PRODUCTS +CERA,CONSTRUCTION +CHAMBLFERT,FERTILISERS & PESTICIDES +CHENNPETRO,ENERGY +CHOLAFIN,FINANCIAL SERVICES +CIPLA,PHARMA +CUB,FINANCIAL SERVICES +COALINDIA,METALS +COCHINSHIP,INDUSTRIAL MANUFACTURING +COFFEEDAY,CONSUMER GOODS +COLPAL,CONSUMER GOODS +CONCOR,SERVICES +COROMANDEL,FERTILISERS & PESTICIDES +CROMPTON,CONSUMER GOODS +CUMMINSIND,INDUSTRIAL MANUFACTURING +CYIENT,IT +DBCORP,MEDIA & ENTERTAINMENT +DCBBANK,FINANCIAL SERVICES +DCMSHRIRAM,CONSUMER GOODS +DLF,CONSTRUCTION +DABUR,CONSUMER GOODS +DEEPAKFERT,CHEMICALS +DELTACORP,SERVICES +DEN,MEDIA & ENTERTAINMENT +DENABANK,FINANCIAL SERVICES +DHFL,FINANCIAL SERVICES +DBL,CONSTRUCTION +DISHTV,MEDIA & ENTERTAINMENT +DCAL,PHARMA +DIVISLAB,PHARMA +DIXON,CONSUMER GOODS +LALPATHLAB,HEALTHCARE SERVICES +DRREDDY,PHARMA +DREDGECORP,SERVICES +EIDPARRY,FERTILISERS & PESTICIDES +EIHOTEL,SERVICES +EDELWEISS,FINANCIAL SERVICES +EICHERMOT,AUTOMOBILE +ELGIEQUIP,INDUSTRIAL MANUFACTURING +EMAMILTD,CONSUMER GOODS +ENDURANCE,AUTOMOBILE +ENGINERSIN,CONSTRUCTION +EQUITAS,FINANCIAL SERVICES +ERIS,PHARMA +EROSMEDIA,MEDIA & ENTERTAINMENT +ESCORTS,AUTOMOBILE +EVEREADY,CONSUMER GOODS +EXCELCROP,FERTILISERS & PESTICIDES +EXIDEIND,AUTOMOBILE +FDC,PHARMA +FEDERALBNK,FINANCIAL SERVICES +FINCABLES,INDUSTRIAL MANUFACTURING +FINPIPE,INDUSTRIAL MANUFACTURING +FSL,IT +FCONSUMER,CONSUMER GOODS +FLFL,CONSUMER GOODS +FRETAIL,CONSUMER GOODS +GAIL,ENERGY +GEPIL,INDUSTRIAL MANUFACTURING +GET&D,INDUSTRIAL MANUFACTURING +GHCL,CHEMICALS +GMRINFRA,CONSTRUCTION +GVKPIL,CONSTRUCTION +GALAXYSURF,CHEMICALS +GDL,SERVICES +GAYAPROJ,CONSTRUCTION +GICRE,FINANCIAL SERVICES +GILLETTE,CONSUMER GOODS +GSKCONS,CONSUMER GOODS +GLAXO,PHARMA +GLENMARK,PHARMA +GODFRYPHLP,CONSUMER GOODS +GODREJAGRO,CONSUMER GOODS +GODREJCP,CONSUMER GOODS +GODREJIND,CONSUMER GOODS +GODREJPROP,CONSTRUCTION +GRANULES,PHARMA +GRAPHITE,INDUSTRIAL MANUFACTURING +GRASIM,CEMENT & CEMENT PRODUCTS +GESHIP,SERVICES +GREAVESCOT,INDUSTRIAL MANUFACTURING +GREENPLY,CONSUMER GOODS +GRINDWELL,INDUSTRIAL MANUFACTURING +GRUH,FINANCIAL SERVICES +GUJALKALI,CHEMICALS +GUJFLUORO,INDUSTRIAL MANUFACTURING +GUJGASLTD,ENERGY +GMDCLTD,METALS +GNFC,CHEMICALS +GPPL,SERVICES +GSFC,FERTILISERS & PESTICIDES +GSPL,ENERGY +GULFOILLUB,ENERGY +HEG,INDUSTRIAL MANUFACTURING +HCL-INSYS,IT +HCLTECH,IT +HDFCBANK,FINANCIAL SERVICES +HDFCLIFE,FINANCIAL SERVICES +HSIL,CONSUMER GOODS +HATHWAY,MEDIA & ENTERTAINMENT +HATSUN,CONSUMER GOODS +HAVELLS,CONSUMER GOODS +HEIDELBERG,CEMENT & CEMENT PRODUCTS +HERITGFOOD,CONSUMER GOODS +HEROMOTOCO,AUTOMOBILE +HEXAWARE,IT +HFCL,TELECOM +HSCL,CHEMICALS +HIMATSEIDE,TEXTILES +HINDALCO,METALS +HAL,INDUSTRIAL MANUFACTURING +HCC,CONSTRUCTION +HINDCOPPER,METALS +HINDPETRO,ENERGY +HINDUNILVR,CONSUMER GOODS +HINDZINC,METALS +HONAUT,INDUSTRIAL MANUFACTURING +HUDCO,FINANCIAL SERVICES +HDFC,FINANCIAL SERVICES +ITC,CONSUMER GOODS +ICICIBANK,FINANCIAL SERVICES +ICICIGI,FINANCIAL SERVICES +ICICIPRULI,FINANCIAL SERVICES +ISEC,FINANCIAL SERVICES +IDBI,FINANCIAL SERVICES +IDFCBANK,FINANCIAL SERVICES +IDFC,FINANCIAL SERVICES +IFBIND,CONSUMER GOODS +IFCI,FINANCIAL SERVICES +IIFL,FINANCIAL SERVICES +IL&FSTRANS,CONSTRUCTION +IRB,CONSTRUCTION +ITDCEM,CONSTRUCTION +ITI,TELECOM +INDIACEM,CEMENT & CEMENT PRODUCTS +ITDC,SERVICES +IBULHSGFIN,FINANCIAL SERVICES +IBREALEST,CONSTRUCTION +IBVENTURES,FINANCIAL SERVICES +INDIANB,FINANCIAL SERVICES +IEX,FINANCIAL SERVICES +INDHOTEL,SERVICES +IOC,ENERGY +IOB,FINANCIAL SERVICES +ICIL,TEXTILES +INDOCO,PHARMA +IGL,ENERGY +INDUSINDBK,FINANCIAL SERVICES +INFIBEAM,IT +NAUKRI,IT +INFY,IT +INOXLEISUR,MEDIA & ENTERTAINMENT +INOXWIND,INDUSTRIAL MANUFACTURING +INTELLECT,IT +INDIGO,SERVICES +IPCALAB,PHARMA +JBCHEPHARM,PHARMA +JKCEMENT,CEMENT & CEMENT PRODUCTS +JKIL,CONSTRUCTION +JKLAKSHMI,CEMENT & CEMENT PRODUCTS +JKTYRE,AUTOMOBILE +JMFINANCIL,FINANCIAL SERVICES +JSWENERGY,ENERGY +JSWSTEEL,METALS +JAGRAN,MEDIA & ENTERTAINMENT +JAICORPLTD,INDUSTRIAL MANUFACTURING +JISLJALEQS,INDUSTRIAL MANUFACTURING +JPASSOCIAT,CEMENT & CEMENT PRODUCTS +JPPOWER,ENERGY +J&KBANK,FINANCIAL SERVICES +JETAIRWAYS,SERVICES +JINDALSAW,METALS +JSLHISAR,METALS +JSL,METALS +JINDALSTEL,METALS +JCHAC,CONSUMER GOODS +JUBLFOOD,CONSUMER GOODS +JUBILANT,PHARMA +JUSTDIAL,IT +JYOTHYLAB,CONSUMER GOODS +KPRMILL,TEXTILES +KIOCL,METALS +KNRCON,CONSTRUCTION +KRBL,CONSUMER GOODS +KAJARIACER,CONSTRUCTION +KALPATPOWR,ENERGY +KANSAINER,CONSUMER GOODS +KTKBANK,FINANCIAL SERVICES +KARURVYSYA,FINANCIAL SERVICES +KSCL,CONSUMER GOODS +KEC,CONSTRUCTION +KOLTEPATIL,CONSTRUCTION +KOTAKBANK,FINANCIAL SERVICES +L&TFH,FINANCIAL SERVICES +LTTS,IT +LICHSGFIN,FINANCIAL SERVICES +LAXMIMACH,INDUSTRIAL MANUFACTURING +LAKSHVILAS,FINANCIAL SERVICES +LTI,IT +LT,CONSTRUCTION +LAURUSLABS,PHARMA +LEMONTREE,SERVICES +LINDEINDIA,CHEMICALS +LUPIN,PHARMA +LUXIND,TEXTILES +MASFIN,FINANCIAL SERVICES +MMTC,SERVICES +MOIL,METALS +MRF,AUTOMOBILE +MAGMA,FINANCIAL SERVICES +MGL,ENERGY +M&MFIN,FINANCIAL SERVICES +M&M,AUTOMOBILE +MAHINDCIE,INDUSTRIAL MANUFACTURING +MHRIL,SERVICES +MAHLOG,SERVICES +MANAPPURAM,FINANCIAL SERVICES +MRPL,ENERGY +MANPASAND,CONSUMER GOODS +MARICO,CONSUMER GOODS +MARUTI,AUTOMOBILE +MFSL,FINANCIAL SERVICES +MAXINDIA,HEALTHCARE SERVICES +MCLEODRUSS,CONSUMER GOODS +MERCK,PHARMA +MINDTREE,IT +MINDACORP,AUTOMOBILE +MINDAIND,AUTOMOBILE +MONSANTO,FERTILISERS & PESTICIDES +MOTHERSUMI,AUTOMOBILE +MOTILALOFS,FINANCIAL SERVICES +MPHASIS,IT +MUTHOOTFIN,FINANCIAL SERVICES +NATCOPHARM,PHARMA +NBCC,CONSTRUCTION +NCC,CONSTRUCTION +NESCO,SERVICES +NHPC,ENERGY +NIITTECH,IT +NLCINDIA,ENERGY +NMDC,METALS +NTPC,ENERGY +NH,HEALTHCARE SERVICES +NATIONALUM,METALS +NFL,FERTILISERS & PESTICIDES +NBVENTURES,ENERGY +NAVINFLUOR,CHEMICALS +NAVKARCORP,SERVICES +NETWORK18,MEDIA & ENTERTAINMENT +NILKAMAL,INDUSTRIAL MANUFACTURING +OBEROIRLTY,CONSTRUCTION +ONGC,ENERGY +OIL,ENERGY +OMAXE,CONSTRUCTION +OFSS,IT +ORIENTCEM,CEMENT & CEMENT PRODUCTS +ORIENTBANK,FINANCIAL SERVICES +PCJEWELLER,CONSUMER GOODS +PIIND,FERTILISERS & PESTICIDES +PNBHOUSING,FINANCIAL SERVICES +PNCINFRA,CONSTRUCTION +PFS,FINANCIAL SERVICES +PTC,ENERGY +PVR,MEDIA & ENTERTAINMENT +PAGEIND,TEXTILES +PARAGMILK,CONSUMER GOODS +PERSISTENT,IT +PETRONET,ENERGY +PFIZER,PHARMA +PHILIPCARB,CHEMICALS +PHOENIXLTD,CONSTRUCTION +PIDILITIND,CHEMICALS +PEL,PHARMA +PFC,FINANCIAL SERVICES +POWERGRID,ENERGY +PRAJIND,INDUSTRIAL MANUFACTURING +PRESTIGE,CONSTRUCTION +PRSMJOHNSN,CEMENT & CEMENT PRODUCTS +PGHH,CONSUMER GOODS +PNB,FINANCIAL SERVICES +QUESS,SERVICES +RBLBANK,FINANCIAL SERVICES +RADICO,CONSUMER GOODS +RAIN,CHEMICALS +RAJESHEXPO,CONSUMER GOODS +RALLIS,FERTILISERS & PESTICIDES +RKFORGE,INDUSTRIAL MANUFACTURING +RCF,FERTILISERS & PESTICIDES +RAYMOND,TEXTILES +REDINGTON,SERVICES +RELAXO,CONSUMER GOODS +RELCAPITAL,FINANCIAL SERVICES +RCOM,TELECOM +RHFL,FINANCIAL SERVICES +RELIANCE,ENERGY +RELINFRA,ENERGY +RNAVAL,INDUSTRIAL MANUFACTURING +RNAM,FINANCIAL SERVICES +RPOWER,ENERGY +REPCOHOME,FINANCIAL SERVICES +RUPA,TEXTILES +RECLTD,FINANCIAL SERVICES +SHK,CONSUMER GOODS +SBILIFE,FINANCIAL SERVICES +SJVN,ENERGY +SKFINDIA,INDUSTRIAL MANUFACTURING +SREINFRA,FINANCIAL SERVICES +SRF,TEXTILES +SADBHAV,CONSTRUCTION +SADBHIN,CONSTRUCTION +SANOFI,PHARMA +SCHAEFFLER,INDUSTRIAL MANUFACTURING +SIS,SERVICES +SHANKARA,METALS +SHILPAMED,PHARMA +SCI,SERVICES +SHOPERSTOP,CONSUMER GOODS +SHREECEM,CEMENT & CEMENT PRODUCTS +RENUKA,CONSUMER GOODS +SHRIRAMCIT,FINANCIAL SERVICES +SRTRANSFIN,FINANCIAL SERVICES +SIEMENS,INDUSTRIAL MANUFACTURING +SPTL,INDUSTRIAL MANUFACTURING +SOBHA,CONSTRUCTION +SOLARINDS,CHEMICALS +SONATSOFTW,IT +SOUTHBANK,FINANCIAL SERVICES +STARCEMENT,CEMENT & CEMENT PRODUCTS +SBIN,FINANCIAL SERVICES +SAIL,METALS +STRTECH,TELECOM +STAR,PHARMA +SUDARSCHEM,CHEMICALS +SPARC,PHARMA +SUNPHARMA,PHARMA +SUNTV,MEDIA & ENTERTAINMENT +SUNDARMFIN,FINANCIAL SERVICES +SUNDRMFAST,AUTOMOBILE +SUNTECK,CONSTRUCTION +SUPREMEIND,INDUSTRIAL MANUFACTURING +SUVEN,PHARMA +SUZLON,INDUSTRIAL MANUFACTURING +SWANENERGY,TEXTILES +SYMPHONY,CONSUMER GOODS +SYNDIBANK,FINANCIAL SERVICES +SYNGENE,PHARMA +TIFIN,FINANCIAL SERVICES +TTKPRESTIG,CONSUMER GOODS +TVTODAY,MEDIA & ENTERTAINMENT +TV18BRDCST,MEDIA & ENTERTAINMENT +TVSMOTOR,AUTOMOBILE +TVSSRICHAK,AUTOMOBILE +TAKE,IT +TNPL,PAPER +TATACHEM,CHEMICALS +TATACOFFEE,CONSUMER GOODS +TCS,IT +TATAELXSI,IT +TATAGLOBAL,CONSUMER GOODS +TATAINVEST,FINANCIAL SERVICES +TATAMTRDVR,AUTOMOBILE +TATAMOTORS,AUTOMOBILE +TATAPOWER,ENERGY +TATASPONGE,METALS +TATASTEEL,METALS +TEAMLEASE,SERVICES +TECHM,IT +TEXRAIL,INDUSTRIAL MANUFACTURING +NIACL,FINANCIAL SERVICES +RAMCOCEM,CEMENT & CEMENT PRODUCTS +THERMAX,INDUSTRIAL MANUFACTURING +THOMASCOOK,SERVICES +THYROCARE,HEALTHCARE SERVICES +TIMETECHNO,INDUSTRIAL MANUFACTURING +TIMKEN,INDUSTRIAL MANUFACTURING +TITAN,CONSUMER GOODS +TORNTPHARM,PHARMA +TORNTPOWER,ENERGY +TRENT,CONSUMER GOODS +TRIDENT,TEXTILES +TIINDIA,AUTOMOBILE +UCOBANK,FINANCIAL SERVICES +UFLEX,INDUSTRIAL MANUFACTURING +UPL,FERTILISERS & PESTICIDES +UJJIVAN,FINANCIAL SERVICES +ULTRACEMCO,CEMENT & CEMENT PRODUCTS +UNICHEMLAB,PHARMA +UNIONBANK,FINANCIAL SERVICES +UBL,CONSUMER GOODS +MCDOWELL-N,CONSUMER GOODS +VGUARD,INDUSTRIAL MANUFACTURING +VMART,CONSUMER GOODS +VIPIND,CONSUMER GOODS +VRLLOG,SERVICES +WABAG,SERVICES +VAKRANGEE,IT +VTL,TEXTILES +VBL,CONSUMER GOODS +VEDL,METALS +VENKEYS,CONSUMER GOODS +VIJAYABANK,FINANCIAL SERVICES +VINATIORGA,CHEMICALS +IDEA,TELECOM +VOLTAS,CONSTRUCTION +WABCOINDIA,AUTOMOBILE +WELCORP,METALS +WELSPUNIND,TEXTILES +WHIRLPOOL,CONSUMER GOODS +WIPRO,IT +WOCKPHARMA,PHARMA +YESBANK,FINANCIAL SERVICES +ZEEL,MEDIA & ENTERTAINMENT +ZENSARTECH,IT +ZYDUSWELL,CONSUMER GOODS +ECLERX,IT diff --git a/tradingsystem/template.html b/tradingsystem/template.html new file mode 100644 index 0000000..41af057 --- /dev/null +++ b/tradingsystem/template.html @@ -0,0 +1,37 @@ + + + + + Order Execution Zerodha + + + + + + +
+
+
+
+
+ Click Submit to place orders + + + + + +
+
+
+
+
+ Last updated at {{date}} +
+
+ + + + + \ No newline at end of file diff --git a/tradingsystem/trading_system.py b/tradingsystem/trading_system.py new file mode 100644 index 0000000..c47a092 --- /dev/null +++ b/tradingsystem/trading_system.py @@ -0,0 +1,227 @@ +""" +Trading system as a script. +See the instructions in the notebook on how this works. +The only change here is that the bhav file is +automatically picked up from the web. You need to +change this manually in the utils.py file if there is a holiday. +""" + +# Import libraries +import pandas as pd +import os +import datetime +import json +from jinja2 import Environment, FileSystemLoader +from utils import * + +# PARAMETERS +# Only change the parameters to + +UNIVERSE = 'NIFTY50' # Universe to be searched +STOP_LOSS = 3 # Stop loss for the order +NUM_STOCKS = 5 # Number of stocks to sell +CAPITAL = 20000 +LEVERAGE = 1 +ORDERFILE_PREFIX = 'orders_' # Prefix file name to store +DIVERSIFY = False # whether to diversify data among sectors +ACCOUNTID = 'XXXXXX' # For any user +APIKEY = 'xxxxxxxxxxxxxxxx' # For zerodha + +# Prepare the dataframe +yesterday, today = pd.bdate_range(end=datetime.datetime.now(), periods=2) +preopen = fetch_preopen_data() +eod = get_bhav_copy(yesterday) +symbols = pd.read_excel('universe.xlsx', sheet_name=UNIVERSE, header=None).values.ravel() +sectors = pd.read_csv('sectors.csv') +df = eod[eod['SYMBOL'].isin(symbols)] +df = df[df['SERIES'] == "EQ"].reset_index(drop=True) +df = df.merge(sectors) + + +# Diversify function for diversifying sectors +def diversify(frame, n=5): + """ + Diversify stocks among sectors + frame + dataframe + n + number of stocks + """ + industry = set() + stocks = [] + for k,v in frame.iterrows(): + if v.at['Industry'] not in industry: + industry.add(v.at['Industry']) + stocks.append(v) + if len(stocks) == n: + break + f = pd.DataFrame(stocks) + if len(f) == 0: + return pd.DataFrame() + else: + return f + +# Trading logic + +df['RET'] = (df['CLOSE']/df['PREVCLOSE']) - 1 +if DIVERSIFY: + result = diversify(df.sort_values(by='RET', ascending=False), NUM_STOCKS) +else: + result = df.sort_values(by='RET', ascending = False).iloc[:NUM_STOCKS] +trading_capital = CAPITAL * LEVERAGE +orders = result.merge(preopen, on='SYMBOL') +num_stock = len(orders) + +# Pricing logic goes here + +orders['trigger_price'] = (orders['OpenPrice'] - 0.05).round(2) +orders['price'] = (orders['trigger_price'] - 0.05).round(2) + +# I prefer a constant percentage change instead of value +# If you prefer it, uncomment the below two lines + +#orders['trigger_price'] = orders['OpenPrice'] * 0.9985 +#orders['price'] = orders['trigger_price'] - 0.05 + +orders['stop_loss'] = (orders['price'] * (1 + STOP_LOSS * 0.01)).apply(tick).round(2) +orders['qty'] = (trading_capital/num_stock/orders['price']).astype(int) +orders['order'] = 'SELL' +filename = ORDERFILE_PREFIX + datetime.datetime.today().strftime('%Y-%m-%d') + '.csv' +orders.to_csv('orders/' + filename, index=False) + +def generate_nest(): + """ + Most brokers and software provide an option to place basket orders. + So we are going to create a basket order from our orders. We would be using the ``create_order`` function from ``utils.py`` file. + To do this for your specific broker, do the following steps + 1. Know the format of your broker; you can do this by placing a basket order and exporting it + 2. The format would usually have a list of columns to be filled up. We need to fill all the columns to import our order. + 3. We separate the columns into columns that are already in our dataframe and columns to be included + 4. We prepare a list of matching columns and rename them + 5. For new columns, we create a python dictionary with keys as column names and values as the value for the column (we assume that these columns have a single value) + + Thanks @vjay for providing the necessary support + """ + # List of columns to be included in the output + + cols = [ + 'Segment', 'InstrumentName', 'Symbol', 'Option Type', 'Strike Price', + 'ExpiryDate', 'Price', 'Qty', 'LTP', 'Buy/Sell', 'Order Type', + 'TriggerPrice', 'Pro/Cli', 'P Type', 'Validity', 'AccountId', + 'Validity Date', 'Remarks', 'Participant code', 'Validity Time', + 'Market Proc' + ] + + # These columns are common for all orders - columns with a single name + columns = { + 'Segment': 'NSE', + 'InstrumentName': 'EQ', + 'Option Type': 'NA', + 'Strike Price': 'NA', + 'ExpiryDate': 'NA', + 'LTP': 0, + 'Disclosed Qty': 0, + 'AccountId': ACCOUNTID, + 'Pro/Cli': 'CLI', + 'Validity': 'DAY', + 'P Type': 'MIS', + 'Remarks': '', + 'Validity Date': 'NA', + 'Participant code': '', + 'Validity Time': 'NA', + 'Market Proc': 'NA', + 'Order Type': 'SL' + } + + # These are columns to be renamed + rename = { + 'order': 'Buy/Sell', + 'price': 'Price', + 'qty': 'Qty', + 'trigger_price': 'TriggerPrice', + 'price': 'Price' , + 'SYMBOL': 'Symbol' + } + + + # Generating orders in the required format + entry_orders = orders.copy() + entry = create_orders(entry_orders, rename=rename, **columns) + + # Exit orders order type and price to be changed + exit_orders = orders.copy() + exit_orders['order'] = 'BUY' + exit_orders['price'] = 0 + exit_orders['trigger_price'] = stop_loss(orders['price'], 3, order='S').round(2) + columns.update({'Order Type': 'SL-M'}) + exit = create_orders(exit_orders, rename=rename, **columns) + + # File generation + entry.append(exit, sort=False)[cols].to_csv('orders_to_place.csv', + index=False, header=False) + + print('File generated for NEST') + +def generate_zerodha(): + """ + Order generation for Kite Zerodha + 1. Sign up for a zerodha publisher api key at(https://kite.trade/) + 2. Update the API key in parameters + 3. This would create an html file **zerodha_order.html** in your present working directory. + 4. Open the HTML file and click the submit button to log into zerodha and place your orders. + 5. Check the updated at time to make sure that this is the latest generated order. + """ + + # List of columns to be included in the output + cols = [ + 'tradingsymbol', 'exchange', 'transaction_type', 'order_type', + 'quantity', 'product', 'validity', 'price', 'trigger_price' + ] + + # These columns are common for all orders - columns with a single name + columns = { + 'exchange': 'NSE', + 'product': 'MIS', + 'validity': 'DAY', + 'order_type': 'SL' + } + + # These are columns to be renamed + rename = { + 'order': 'transaction_type', + 'price': 'Price', + 'qty': 'quantity', + 'trigger_price': 'trigger_price', + 'price': 'price' , + 'SYMBOL': 'tradingsymbol' + } + + # Generating orders in the required format + entry_orders = orders.copy() + entry = create_orders(entry_orders, rename=rename, **columns) + + # Exit orders order type and price to be changed + exit_orders = orders.copy() + exit_orders['order'] = 'BUY' + exit_orders['price'] = 0 + exit_orders['trigger_price'] = stop_loss(orders['price'], 3, order='S').round(2) + columns.update({'order_type': 'SL-M'}) + exit = create_orders(exit_orders, rename=rename, **columns) + trades = entry.append(exit, sort=False)[cols].to_dict(orient='records') + + # Order HTML file generated + env = Environment(loader=FileSystemLoader('.')) + template = env.get_template('template.html') + output_from_parsed_template = template.render(api_key = APIKEY, + orders=json.dumps(trades), + date=str(datetime.datetime.now())) + + with open('zerodha_order.html', 'w') as f: + f.write(output_from_parsed_template) + print('Zerodha order file generated') + +if __name__ == "__main__": + generate_nest() + generate_zerodha() + + diff --git a/tradingsystem/universe.xlsx b/tradingsystem/universe.xlsx index 477c862..f86c5c1 100644 Binary files a/tradingsystem/universe.xlsx and b/tradingsystem/universe.xlsx differ diff --git a/tradingsystem/utils.py b/tradingsystem/utils.py index 9a7465d..78e7ce0 100644 --- a/tradingsystem/utils.py +++ b/tradingsystem/utils.py @@ -59,7 +59,7 @@ def fetch_preopen_data(url=None): """ import requests if url is None: - url = "https://www1.nseindia.com/live_market/dynaContent/live_analysis/pre_open/nifty.json" + url = "https://www1.nseindia.com/live_market/dynaContent/live_analysis/pre_open/all.json" req = requests.get(url) dct = req.json() agg = [] @@ -72,3 +72,29 @@ def fetch_preopen_data(url=None): df["iep"] = df.iep.astype("f8") df.columns = ['SYMBOL', 'PctChange', 'OpenPrice'] return df + +def get_bhav_copy(date): + """ + Get bhav copy for NSE for a given date and + convert it into a dataframe + TO DO: Add BadFile Exception + """ + from zipfile import ZipFile + from io import BytesIO + + d = pd.to_datetime(date) + print(d) + year = d.strftime('%Y') + month = d.strftime('%b').upper() + base_url = f'https://www.nseindia.com/content/historical/EQUITIES/{year}/{month}/cm' + headers = {'Referer': 'https://www.nseindia.com/products/content/all_daily_reports.htm'} + bhavfile = base_url + d.strftime('%d%b%Y').upper() + 'bhav.csv.zip' + print(bhavfile) + # Uncomment the below for custom date + # bhavfile = 'customURL' + req = requests.get(bhavfile, headers=headers) + z = ZipFile(BytesIO(req.content)) + fn = z.namelist()[0] + with z.open(fn) as f: + db = pd.read_csv(f, index_col=0, parse_dates=['TIMESTAMP'], usecols=range(12)) + return db.query('SERIES == "EQ"').reset_index() diff --git a/tradingsystem/windows_runner.bat b/tradingsystem/windows_runner.bat new file mode 100644 index 0000000..8bd9842 --- /dev/null +++ b/tradingsystem/windows_runner.bat @@ -0,0 +1,5 @@ +:: Change path to your tradingsystem path + +cd tradingsystem +cd +python trading_system.py \ No newline at end of file diff --git a/tradingsystem/zerodha_order.html b/tradingsystem/zerodha_order.html new file mode 100644 index 0000000..3cde93f --- /dev/null +++ b/tradingsystem/zerodha_order.html @@ -0,0 +1,37 @@ + + + + + Order Execution Zerodha + + + + + + +
+
+
+
+
+ Click Submit to place orders + + + + + +
+
+
+
+
+ Last updated at 2018-10-24 20:35:49.258456 +
+
+ + + + + \ No newline at end of file