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": [
+ "
"
+ ],
+ "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",
+ "
date
\n",
+ "
spot
\n",
+ "
strike_pr
\n",
+ "
option_typ
\n",
+ "
signal
\n",
+ "
\n",
+ " \n",
+ " \n",
+ "
\n",
+ "
0
\n",
+ "
2019-01-01
\n",
+ "
10881.70
\n",
+ "
10800
\n",
+ "
CE
\n",
+ "
1
\n",
+ "
\n",
+ "
\n",
+ "
1
\n",
+ "
2019-01-02
\n",
+ "
10868.85
\n",
+ "
10800
\n",
+ "
CE
\n",
+ "
1
\n",
+ "
\n",
+ "
\n",
+ "
2
\n",
+ "
2019-01-03
\n",
+ "
10796.80
\n",
+ "
10700
\n",
+ "
CE
\n",
+ "
1
\n",
+ "
\n",
+ "
\n",
+ "
3
\n",
+ "
2019-01-04
\n",
+ "
10699.70
\n",
+ "
10600
\n",
+ "
CE
\n",
+ "
1
\n",
+ "
\n",
+ "
\n",
+ "
4
\n",
+ "
2019-01-07
\n",
+ "
10804.85
\n",
+ "
10800
\n",
+ "
CE
\n",
+ "
1
\n",
+ "
\n",
+ " \n",
+ "
\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": [
+ "
+
+
+
+
+
\ 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
+
+
+
+
+
+
+