Tewani, Puneet - Step by Step Automation Using Zerodha API - Python Version (2020)

ACKNOWLEDGEMENTS
I would like to thank all my mentors, especially Mr. Vihan Singh.

I would like to also sincerely thank interns of Fox Trading Solutions, who
have helped me in writing this book.
The book cover is designed by Snehil Agrawal and the creator should
always be acknowledged.
PREFACE
This book is a concise summary of our years of work in Algorithmic
Trading, creating algorithmic solutions for buying and selling instruments
based on your wonderfully created complex or simple yet extremely elegant
strategies. We have just tried to share a gist of it in this book Titled
“Algorithmic Trading using Zerodha's KiteConnect API in Python”.
Throughout this book, we will take you through a journey from a beginner
to an experienced Algorithmic Trader with basic knowledge in python,
Algorithmic trading, and trading strategies. We will introduce the reader to
the basics of python necessary for Algorithmic Trading. We will introduce
the reader with enough python to have a comfortable understanding of this
entire course.
The world of the stock market attracts every person some time or another
by its glitter of easy earning and quick money. Nevertheless, soon they have
to understand the stock markets are not all rosy and there are high risks and
losses also. However, the thing about Algorithmic Trading is that we can
assign this task of buying and selling instruments to an algorithm, which
will make the readers' tasks more manageable and let the reader focus only
on building automated trading strategies instead of execution. Which by the
way we are experienced in doing, and it is time for you to sit back and let
algorithms trade on your behalf.
CONTENTS
1. Introduction
1.1 Introduction
1.2 Installation & Setting of Python
1.3 Install Pip
1.4 Setting of Jupyter Notebook
1.5 Working with Jupyter Notebook
2. Variables
2.1 Input variables
2.2 User Input
2.3 Types of variables
2.4 Printing a variable
2.5 Identify variable type
2.6 Type Casting
3. Strings
3.1 Introduction
3.2 Splitting a string
3.3 Slicing a string
3.4 Concatenate String
3.5 String Formatting
4. Operators
4.1 Arithmetic, Assignment, Comparison operators
4.2 Logical and Identity operator
5. Conditional Statement
5.1 If
5.2 If Else
5.3 Elif
5.4 NestedIf
6. Loop
6.1 For
6.2 While
6.3 Continue & Pass
6.4 Break
7. List
7.1 Introduction to list
7.2 Add & Remove items in list
8. Tuple
8.1 What is Tuple
8.2 Operation in Tuple
9. Introduction to Dictionary
9.1 Loop through Dictionary
9.2 Add/Remove items in Dictionary
10. Functions
10.1 Introduction to Function
10.2 Default parameter & Written Statement
10.3 Lambda Function/ Anonymous Function
11. Classes & Objects
11.1 Object Oriented Programming
11.2 Class
11.3 Implementation of Objects in Python
12. NumPy
12.1 NumPy
13 . Pandas
13.1 Data Frame & Series
13.2 Indexing
14. Data Visualization
14.1 Matplotlib
14.2 Seaborn
14.3 Plotting
15. What is API
15.1 API
15.2 How to interact with API
16. Zerodha API
16.1 Getting Started With KiteConnect
16.2 Create a Trading Application
16.3 Access Token generation
16.4 Installing KiteConnect
16.5 Get Historical data
16.6 Fetching Instrument token
16.7 Streaming Trick Data
16.8 Placing order
16.9 Cancel order
16.10 Order History
17. Technical Indicators & Price Action techniques
17.1 Import Technical Indicator from Library
17.2 Coding technical indicators
17.2.1 MACD
17.2.2 Bollinger Band
17.2.3 Average True Range(ATR)
17.2.4 Relative Strength Index(RSI)
17.2.5 Average Directional Index (ADX)
17.2.6 Supertrend
17.2.7 Chaikin Money Flow(CMF)
17.2.8 Ichimoku Cloud
17.2.9 On-Balance Volume
17.3 Price Action Techniques
17.3.1 Doji
17.3.2 Hammer
17.3.3 Shooting Star
17.3.4 Marubozu
18. Handling Streaming Tick Data
18.1 Starting Streaming Data to CSV
18.2 Converting Ticks to Candles
18.3 Sample strategy
CHAPTER 1
Introduction
1.1 Introduction To Python
Python is a modern day programming language. It is the most simplified
version of human-machine interaction.
Python’s official description:
It has efficient high-level data structures and a simple but effective
approach to object-oriented programming. Python's elegant syntax and
dynamic typing, together with its interpreted nature, make it an ideal
language for scripting and rapid application development in many areas on
most platforms.
Features of python
● Simple
● Open Source
● Easy syntax
● Powerful Looping
● High-Level Language
● Object-Oriented
__________________________________________________
Fox Trading Solutions Repository:www.https://github.com/FoxTradingSolutions/
1.2 Installing & Setting Up Python
Visit https://www.python.org/downloads/ and download the latest version.
The current version of python is 3.8.2 and it gets updated pretty fast.
Double click on exe to install.
Please make sure you check the option Add Python 3.8.2 to the PATH.If
you forget to add python 3.8.2 to path, go to environment variables in
windows and add python to PATH. This will enable you to access it from
the command prompt.
The default interface which will be installed along with python is called
IDLE. It runs the code line by line and is the least preferred option to work
with. There are various IDEs which support python. The simplest and the
most powerful being Jupyter notebook, which will be discussed further.
__________________________________________________
1.3 Installing PIP
PIP is the package installer for python. By using pip you can install any
library you need. The library is a collection of pre-coded files which serves
a purpose, they are built for specific purposes and can be used within our
code.
The module PIP comes pre-installed in most of the python installations. If it
is not there, you can install it by following the below mentioned steps.
To install PIP, you need to download the get-pip.py file from
https://bootstrap.pypa.io/get-pip.py .
Open this link in any browser and save it by pressing Ctrl+S . The
directory in which you are saving this file should be the same as the one in
which python is installed.
After saving the file, go to command prompt and write the following code
python get-pip.py
This will install PIP.
__________________________________________________
1.4 Installing Jupyter Notebook
It is a web-based interpreter, used to run python code. It holds the title of
being the simplest interpreter.Installing a Jupyter notebook is pretty simple.
Go to command prompt and run the following code:
pip install Jupyter notebook
This will install your Jupyter notebook.
__________________________________________________
1.5 Working With Jupyter Notebook
Working with a Jupyter notebook is pretty easy. Just open the command
prompt and type Jupyter notebook. Surprisingly, it will open in a browser
window.
To create a new notebook, click New on the top right corner and select
python3 from there.This will open up a new file.
__________________________________________________
CHAPTER 2
Variables
2.1 Input Variables
Variables in Python are used to store data or collections of data. Python uses
dynamic casting to store data which means unlike languages like C, C++,
etc. There is no need to initialize variables with data type in python.
Example:
stoploss = 5
target=50
stock_name = ‘Reliance’
exchange = “NFO”
Rules for variable declarations in python -
● A variable name must start with a letter or the underscore character
● A variable name cannot start with a number
● A variable name can only contain alpha-numeric characters and
underscores
● Variable names are case-sensitive
__________________________________________________
2.2 User Input
Input can be provided to the program in python using the “input” function.
We can ask the user to input values if they aren’t pre-defined
Example:
stoploss = input()
A predefined message can also be outputted while taking the input by
putting that message as a function parameter.
Example:
a = input(“What is your stop loss?”)
Python always takes inputs as a string. Hence to use the input as a number,
i.e. to perform addition, subtraction, multiplication, etc, you need to convert
the input to a number, using an appropriate function like int(), float(), etc.
Depending on the type of variable you want.
Example
a = int(input()) #for integers
b = float(input()) #for numbers with
decimal point
__________________________________________________
2.3 Types Of Variables
There are various types of variables:
1. Integer:
Integers are whole number, without decimal points

Example: 1,2,3,4
2. Float:
Numbers with decimal points

Example: 1.258, 2.587
3. Strings: Strings are a combination of characters. In simple terms,
it’s a word.
Example: ‘Nifty’,’Banknifty’.
__________________________________________________
2.4 Printing A Variable
The print function gives a standard output. The output is displayed on the
screen which helps us to verify our input.
Example of a print statement:

stoploss=5
print(“your stoploss is”,stoploss)
Output:
your stoploss is 5
__________________________________________________
2.5 Identify Variable Type
The type of variable you have entered.How it works:
quantity = 1
print(type(quantity))
Output :
<class int>
Example 1:
price=52.35
print(type(price) )
Output:
<class float>
Example 2:
stock_name =’Reliance’ ’
print(type(stock_name))
Output:
<class str>
__________________________________________________
2.6 Type Casting
We can convert one data type into another by using typecasting. Below
shown is how it works
price = 50.50
print(type(price))
Output:
<class float>
We can convert this price which is in float to an integer by using the
following command
print(int(price))
Output:
50
In a similar way, int, float, string can be converted from one to another. The
only exception is strings formed using characters cannot be converted to int
or float.
__________________________________________________
CHAPTER 3
Strings
3.1 Introduction
A string is a sequence of characters. Strings are basically just a bunch of
words.Strings form an integral part of every program. Whenever we define
any variable, we have to use strings. Strings are defined in quotes. There are
3 types of quotes in python.
Single quotes
Writing your string in single quotes is like ‘What is your stoploss’
Double quotes
Strings in double quotes work exactly the same way as strings in single
quotes.
Example: “What is your stoploss”
Triple Quotes
Strings in triple quotes are used as comments. Comments basically mean
you don’t want to include them in the program. They are in simple english
and placed above almost every line of code. They help us understand how
the code is structured and what the code is doing.
__________________________________________________
Indentation:
Indentation refers to the spaces at the beginning of a code line. Indentation
is very important in python. Python uses indentation to indicate a block of
code. Indentation is used by clicking either one tab or four spaces and using
only one of them at a time for better code management.
Example-
if 10>5:
print (‘Ten is greater than five’)
Python will give you an error if you skip the indentation.
Example-
if 10>5:
print (‘Ten is greater than five’)
In this example, it will show you a Syntax error.
Alias:
In python, Alias is an alternate name for referring to the same thing.
Create an alias with the ‘as’ keyword while importing:
import numpy as np
import pandas as pd
__________________________________________________
3.2 Splitting A String
We can split the string into various parts. The splitting can be done using
any character or special character.
Example:
stock_name=”Reliance-NFO”
print(stock_name.split(“-”))
Output:
['Reliance', 'NFO']
__________________________________________________
3.3 Slicing A String
We can slice the string using the length function. The first step in slicing a
string is finding its length.
How it works:
stock_name=”Reliance-NFO’
print(len(stock_name))
Output:
12
If we want to slice string, we can do it
Example 1:
string=”Price of Reliance is 1400”
print(string[9:17])
Output:
Reliance
Example 2:
print(string[21:])
Output:
1400
__________________________________________________
3.4 Concatenate String
String concatenation means merging 2 strings into one string. How it works:
stock_name = "Reliance"
exchange="NFO"
Combined_name=print(stock_name+exchange)
Output:
RelianceNFO
__________________________________________________
3.5 String Formatting
We use it to format a string in a manner we want.
price = 1400
stock_name = “Reliance”
print('{0} is trading at Rs
{1}'.format(stock_name, price ))
Output:
Reliance is trading at Rs 1400.
__________________________________________________
CHAPTER 4
Operators
4.1 Arithmetic, Assignment, Comparison Operators
Arithmetic operators in python are used with numeric values to perform common mathematical
operations.
Operator Name Example
+ Addition x+y
- Subtraction x-y
* Multiplication x*y
/ Division x/y
% Modulus x%y
** Exponentiation x ** y
// Floor division x // y
__________________________________________________
Assignment operators in python are used to assign values to variables.
Operator Example Same As
= x=5 x=5
+= x += 3 x=x+3
-= x -= 3 x=x-3
*= x *= 3 x=x*3
/= x /= 3 x=x/3
%= x %= 3 x=x%3
//= x //= 3 x = x // 3
**= x **= 3 x = x ** 3
&= x &= 3 x=x&3
|= x |= 3 x=x|3
^= x ^= 3 x=x^3
>>= x >>= 3 x = x >> 3
<<= x <<= 3 x = x << 3
Comparison operators in python are used to compare two values:
Operator Name Example
== Equal x == y
!= Not equal x != y
> Greater than x>y
< Less than x<y
>= Greater than or equal to x >= y
<= Less than or equal to x <= y

4.2 Logical And Identity Operator
Logical operators in python are used to combine conditional statements.
Operator Description Example
and Returns True if both statements are true x < 5 and x < 10
or Returns True if one of the statements is x < 5 or x < 4

true
not Reverse the result, returns False if the not(x < 5 and x < 10)
result is true
Identity operators in python are used to compare the objects, not if they are equal, but if they are
actually the same object, with the same memory location
__________________________________________________
Operator Description Example
is Returns True if both variables are the same x is y

object
is not Returns True if both variables are not the x is not y

same object
__________________________________________________
CHAPTER 5
Conditional Statements
5.1 If
If statements are conditional statements in python which roughly translates
to english as - if the condition is true then execute this code block. If the
condition of an if returns a boolean True then the code block of that if is
executed.
Example-
stock_price = 5
if (stock_price>2):
print(“greater”)
Output-
greater
__________________________________________________
5.2 IF Else
If Else are one of the most common keywords in any language which
describe the conditional changes during the execution of the code. The code
block of if is executed if the condition of if is true but if it is not true then
the code block of else is executed.
Example:
stock_price = 5
if(stock_price=4):
print("stock_price is 4")
else:
print("stock_price is not equal to 4")
Output:
stock_price is not equal to 4
__________________________________________________
5.3 ElIf
Mostly the if statement cannot hold all the possible conditions of an
outcome. Hence the elif or as we speak elseif; condition is checked. The
number of elif can be more than one for an if statement.
Example:
stock_price = 4
if(stock_price>5):
print("Big")
elif(stock_price<5):
print("Small")
else:
print("Match")
Output:
Small
__________________________________________________
5.4 Nested If
If statements are used for conditional executions in python. If-elif-elif- -else
is the basic structure of any Nested If statements. It basically follows a top
down approach, first the if condition is tested, if that is true then the if block
statements are executed but if not then the first elif statement is tested and
executions are performed based on its truth value. After all if and elif are
tested and none are true then at last the else statement is executed.
Example:
x = 4
if(x>4):
print(“greater”)
if(x<4):
print(“less”)
else:
print(“equal”)
Output:
Equal
__________________________________________________
CHAPTER 6
Loops
6.1 For Loop
For loop is used for iterations in python. It is used to iterate over lists,
tuples, generators etc.Unlike other languages like C, C++ etc, python does
not support numeric for loops by default. To iterate over a range of numbers
one has to create a range generator by specifying starting, ending, and jump
value to the range function.
Example :
for x in range(1,5,2):
print(x)
Output :
1
3
For loops can also iterate over predefined arrays and tuples by using the
“in” keyword.
__________________________________________________
Example:
a = [“a”,”b”,”c”]
for x in a:
print(x)
Output:
a
b
c
__________________________________________________
6.2 While
While loops are similar to for loops in the manner that they repeat the same
code lines over and over again but different in the sense that they are not
statically driven. It means that the looping condition of while loops can
change during the execution of the loop unlike in the case of for loops
where the driving condition remains same during the entire execution.
Example -
x = 4
while x>1:
print(x)
x-=1
Output-
4
3
2
__________________________________________________
6.3 Continue & Pass
Just like any other programming language the “continue” statement is used
to skip the current loop state in a python for or while loop.
Example-
for x in range(8):
if(x%2):
continue
else:
print(x)
Output-
1
3
5
7
Execution blocks in python whether they belong to if, elif, else, try, except,
function, class, etc can never be empty. But due to certain conditions we
need to keep them empty for say, testing, development or code requirement.
Hence to keep an execution statement from performing any execution
“pass” keyword is used to tell the compiler to do nothing if this keyword is
encountered.
__________________________________________________
Example-
A = 10
if(A>10 or A<10):
pass
else:
print(“A is 10”)
Output-
A is 10
__________________________________________________
6.4 Break
Break statement is executed when they meet a condition, which is checked
in the loop during every iteration. Break statement ends the loop and
executes the code, written after the loop.
Simply known as coming out of the loop.
Example of Break-
i=1
while(i<10):
print(i)
If (i==5):
break
i=i+1
Output-
1
2
3
4
__________________________________________________
CHAPTER 7
Lists
7.1 Introduction To List
Lists in python contain one or more than types of data at linear indices
starting from 0. In Python lists can be defined by using the keyword “list”
or by directly placing the data of the list into square brackets “[ ]” .
Example-
a = [1,2,3,4]
print(type(a))
Output-
<class 'list'>
The data inside a list can be accessed by providing the index of the data to
the list inside square brackets or by iterating over it inside a for loop.
Example-
a = [1,2,3,4]
print(a[-1])
Output-
4
__________________________________________________
Example-
a = [1,2,3]
for x in a:
print(x)
Output-
1
2
3
__________________________________________________
7.2 Add & Remove Items In List
Items can be added to a list using the append function. Append function
adds an item to the list by increasing it length then inserting it at the end.
Example -
a = [1,2,3,4]
print(a)
a.append(0)
print(a)
Output -
[1, 2, 3, 4]
[1, 2, 3, 4, 0]
Data can also be added to the list by assigning data to a pre existing index
of a list.
Example-
a = [1,2,3,4]
print(a)
a[2] = 7
print(a)
Output-
[1, 2, 3, 4]
[1, 2, 7, 4]
__________________________________________________
Data can also be removed by list:

Example:
a = [1,2,3,4]
a.pop(3) #it will remove 3rd element from
list
print(a)
Output-
[1, 2, 3]
__________________________________________________
CHAPTER 8
Tuple
8.1 What Is Tuple
A tuple is an immutable sequence of Python objects. Tuples are sequences,
just like lists. The differences between tuples and lists are, the tuples cannot
be changed unlike lists and tuples use parentheses “( )”, whereas lists use
square brackets “[ ]”.
Tuples are statically created hence they cannot be mutated once they are
created and this makes using them faster than lists. They can be created
using parentheses and commas for separating objects.
Example -
a = ('a',1,"hello")
__________________________________________________
8.2 Operation In Tuple
Python Expression Results Description
len((1, 2, 3)) 3 Length
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenation
('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') Repetition
3 in (1, 2, 3) True Membership
for x in (1, 2, 3): 123 Iteration

print(x),
__________________________________________________
CHAPTER 9
Dictionary
9.1 Loop Through Dictionary
Dictionary is similar to a list in the manner that it stores data at indices too
but different in the sense that in a dictionary we have to define the index at
which we need to place data, there is no function like append, for a
dictionary and indices can be string too.
A dictionary has two variables per entry - a key and a value. They can be
accessed using the items function over a dictionary object. The items
function returns a list of tuples containing key value pairs which can be
iterated over using a for loop.
Example-
a = {'one':1,"apple":"banana",8:9}
for k,v in a.items():
print(f"{k} -> {v}")
Output-
one -> 1
apple -> banana
8 -> 9
_________________________________________________
9.2 Add/Remove Items In Dictionary
Adding data to a dictionary is similar to adding data to a list at an index, but
there is a small difference that in a dictionary you can create any index
irrespective of its order or data type.
Example-
a['newData'] = 4
print(a)
Output-
{'one': 1, 'apple': 'banana', 8: 9, 'newData':
4}
Deletion operation in dictionaries is also very simple. It is done using the
“del” keyword.
Example-
del a['one']
print(a)
Output-
{'apple': 'banana', 8: 9}
__________________________________________________
CHAPTER 10
Functions
10.1 Introduction To Function
Function is a block of code that performs a specific task. We can do many
things using functions. Some of the advantages of using functions are listed
below:
1. Code Reusability: We are writing an application in Python where we
need to perform a specific task in several places of our code, assuming that
we need to write 10 lines of code to do that specific task. It would be better
to write those 10 lines of code in a function and just call the function
wherever needed.
2. Improves Readability: By using functions for frequent tasks you make
your code structured and readable. It would be easier for anyone to look at
the code, and helps us in making tidier code.
3. Avoid redundancy: When you no longer repeat the same lines of code
throughout the code.
There are two types of functions in Python:

1. Built-in functions: These functions are predefined in Python and
we need not to declare these functions before calling them.
Example:
square = math.pow(a, 2)
__________________________________________________
2. User defined functions: The functions which we create in our

code are user-defined functions. The computation() function that
we have created in the below example is a user-defined function.
User Defined Function Template-

def <functionName> ( [<parameter1>,
[<parameter2>, …]]):
<functionCode>
return [<resultVariable>]
Example-
def computation(a):
square = a*a
return square
Usage-
x = float(input("Var1: "))
y = computation(x)
print(y)
Output
Var1: 2
4
Note:If you don’t include a return statement in your function,the interpreter
will automatically return
None value.
__________________________________________________
10.2 Default Parameter & Written Statement
Parameters are the variables we send to a function for its execution. In
python we can sometimes set that data to a default value so as to use that
function with or without passing that variable. Such parameters with default
values are called default parameters.
Example -
def add(a,b,d=0):
c = a+b+d
return c
x = add(3,4)
print(x)
y = add(3,4,5)
print(y)
Output-
7
12
__________________________________________________
10.3 Lambda Functions/ Anonymous Functions
Anonymous functions are functions without names. Lambda keyword is
used to create anonymous functions. Lambda function does not include a
“return” statem-ent, it always contains an expression which is returned.
Example-
g=lambda x: x*x*x # here x is the argument
and x*x*x is the expression
g(2)
Output:
8
__________________________________________________
CHAPTER 11
Classes & Objects
11.1 Object Oriented Programming
Python as a language supports Object Oriented Programming (hereafter
called as OOP). OOP is an approach for writing programs in which data and
behaviour are blinded together as classes and the instances of these classes
are defined objects. The OOP is based on certain concepts which are briefly
defined as below.
1. Data Abstraction – It is the way of representing the essential features
without including the background details and explanations.
Example:
Your car is a great example of abstraction. You can start a car by turning the
key or pressing the start button. You don't need to know how the engine is
getting started, what all components your car has. The car internal
implementation and complex logic is completely hidden from the user.
2. Data Hiding – Data hiding ensures exclusive data access to class
members and protects object integrity by preventing unintended or intended
changes .Data hiding insulates the data from the straight access by the
program.
Example:
You have an account in a XYZ Bank.You can only transfer or check money
in your account.You can’t edit the money in your account. This is called
Data Hiding.
__________________________________________________
3. Data Encapsulation – It is the process of wrapping up the data and its

associated functions along with it. It also implements abstraction in a way.
4. Inheritance – It is the capability of one class to inherit properties from
another class. The class which is inherited is called as the base class and the
class which inherits from another class is called as derived class. The
derived class has all the properties of base class by default.
5. Polymorphism – It is the ability of a data to be processed in more than
one form. It is the property by which the same message can be sent to
objects of several classes.
For example: 2+3 results in 5 but ‘A’ + ‘B’ results in ‘AB’. The same
operator symbol ‘+’ is able to distinguish between the two operations
depending upon the data type it is working upon.
__________________________________________________
11.2 Class
A Class is a way to bind the data and its associated functions together. For
instance, consider a fruit having characteristics, taste, colour and its size.
When a class is defined, memory is allocated for its member functions and
they are stored in the memory. When an object is created, separate memory
space is allocated for its data members. All objects work with one copy of
the member function shared by all. The declaration of a class involves three
things:
1. Data members which are the data type properties to describe the
characteristics of a class.
2. Member functions are the set of operations to be carried out to objects
of that class. They are referred to as class interfaces.
3. Access levels that control access to members from within the program.
These access levels are private, public or protected. Depending upon the
access level of a class member, access to it is allowed or denied.
__________________________________________________
11.3 Implementation Of Objects In Python
The objects are implemented through member functions called as methods
and it is given a unique name to make it identifiable in a unique manner.
Once a class has been defined, its objects can be created like any other
variable, using the class name as type specifier.
Example-
class data:
def __init__(self, symbolName, market):
self.symbol = symbolName
self.market = market
self.ltp = []
def newLtp(ltp):
self.ltp.append(ltp)
nifty = data(‘Nifty’,’NSE’)
bankNifty = data(‘Nifty Bank’,
’NSE’)
gold = data(‘GOLD APR FUT’, ’
NFO’)
nifty.newLtp(51341.12)
gold.newLtp(37920.14)
gold.newLtp(37921.55)
__________________________________________________
Here data is the class and nifty, bankNifty, gold are the objects of that class.
The class stores the symbols’ name, its market and list to store all its ltp
values.
_____________________________________________
CHAPTER 12
NumPy
12.1 NumPy
NumPy is an inbuilt library, which is used for numerical computations. It is
basically used because of its computational efficiency in terms of speed.
Numerical python (NumPy) supports multidimensional arrays over which
you can easily apply mathematical operations. It is a single (homogeneous)
data type. NumPy’s arrays class is “ndarray,” also referred to as
“numpy.array”
Installing NumPy-
!pip install numpy
Once NumPy is installed, import it into your application by adding the
“import” keyword.
Example-
a=[1,2,3,4,5]
b=[2,4,6,6,8]
npa_array=np.array(a)
npb_array=np.array(b)
npa_array+npb_array
Output-
array([3,6,9,10,13])
__________________________________________________
Accessing array Elements: Indexing

Example-
a=np.array([[1,3,4,5],[2,3,4,7]])
b=a[0]
b
Output-
array([1,3,4,5])
Where
This function returns elements chosen from x or y depending on condition.
numpy.where(condition[, x, y])
here,
condition : Where True, yield x, otherwise yield y.
x : yielded when condition is True
y : yielded when condition is False
If the yielding elements x and y are not provided the True and False are
yielded as the placeholders.
Example -
a = np.array(range(10))
np.where(a < 5, a, 10*a)
__________________________________________________
Output -
array([ 0, 1, 2, 3, 4, 50, 60, 70, 80, 90])
Random
This function returns random integers from low (inclusive) to high
(exclusive). It returns random integers from the “discrete uniform”
distribution of the specified dtype in the “half-open” interval [low, high). If
high is None (the default), then results are from [0, low).
numpy.random.randint(low,high=None, size= None ,
dtype=int)
here,
low : range starting
high : range ending
size : size of output array
dtype : data type of output
Example -
np.random.randint(5,10,(3,4))
__________________________________________________
Output -
array([[6, 8, 7, 9],
[5, 5, 5, 9],
[9, 8, 6, 7]])
__________________________________________________
CHAPTER 13
Pandas
13.1 Data Frame & Series
Pandas is a fast, powerful, flexible and easy to use open source data
analysis and manipulation tool, built on top of the Python programming
language.
A Data frame is a two-dimensional data structure, in which data is aligned
in a tabular fashion in rows and columns.
Pandas Series is a one-dimensional labeled array capable of holding data of
any type. The axis labels are collectively called indexes. Pandas Series is
nothing but a column in an excel sheet.
Installing Pandas-
pip install pandas
Series and DataFrames can be created with different data inputs :-
1.list
2.dictionary
3.scalar
4.ndarrays (Import NumPy while working with ndarray)
__________________________________________________
Series Example of ndarray:-
import pandas as pd
import numpy as np
np_name=np.array([‘abc’,’xyz’,’lmn’,’pqr’])
s_name=pd.Series(np_name)
print(s_name)
Output-
1 Abc
2 xyz
3 lmn
4 pqr
DataFrame example of ndarray-
import pandas as pd
import numpy as np
np_name=np.array([‘abc’,’xyz’,’lmn’,’pqr’])
df_name=pd.Dataframe(np_name)
print(df_name)
Output-
0 abc
1 xyz
2 lmn
3 pqr
__________________________________________________
Dataframe Example -
import pandas as pd
d = {'col1': [1, 2], 'col2': [3, 4]}
df = pd.DataFrame(data=d)
print(df)
Output-
col1 col2
0 1 3
1 2 4
Series Example-
import pandas as pd
data = ['g','e','e','k','s']
ser = pd.Series(data)
print(ser)
Output-
0 g
1 e
2 e
3 k
4 s
dtype: object
__________________________________________________
13.2 Indexing
A pandas series is a simple array and can be indexed similarly. Each row
and column in a pandas dataframe is a seperate pandas series hence they
can be indexed like an array too.
Pandas Series Indexing-
import pandas as pd
a = [4,5,6]
s = pd.Series(a)
print(s[1])
Output-
5
Pandas Dataframe Indexing-

Indexing in python can be done along rows and columns. By default the
square bracket indexing on pandas is reserved for column indexing. To
index across rows “loc” and “iloc” functions are used on the pandas
dataframe.
loc gets rows with particular labels from the index.
iloc gets rows at particular positions in the index (so it only takes integers).
__________________________________________________
Example-
import pandas as pd
data = {'Name':['Tommy', 'nicky', 'krishna', 'jacky'], 'Age':
[23, 21, 18, 28], 'Qualification':['Msc', 'MA', 'MCA', 'Phd']}
df=pd.DataFrame(data, index= ['a', 'b', 'c', 'd'])
print(df['Name'])
Output-
a Tommy
b nicky
c krishna
d jacky
Name: Name, dtype: object
Example-
import pandas as pd
data={'Name':['Tommy','nicky', 'krishna', 'jacky'], 'Age':[23,
21, 18, 28],'Qualification':['Msc', 'MA', 'MCA', 'Phd']}
df=pd.DataFrame(data, index= ['a', 'b', 'c', 'd'])
print(df.iloc[2])
Out put -
Name krishna
Age 18
Qualification MCA
Name: c, dtype: object
__________________________________________________
Example-
import pandas as pd
data={'Name':['Tommy','nicky','krishna',
'jacky'],'Age':[23, 21, 18, 28],'Qualification':
['Msc', 'MA', 'MCA', 'Phd']}
df=pd.DataFrame(data,index=['a','b','c','d'])
print(df.loc['d'])
Output-
Name jacky
Age 28
Qualification Phd
Name: d, dtype: object
__________________________________________________
CHAPTER 14
Data Visualization
Data visualisation forms an integral part of any strategy as we formulate

most of the strategies seeing charts.
We would be using two inbuilt libraries namely matplotlib and seaborn
which helps us in visualising data.
__________________________________________________
14.1 Matplotlib:
Matplotlib library is used for plotting graphs in python.
Installation: pip install matplotlib
Import:
import matplotlib.pyplot as plt
( Matplotlib is a toolkit, Pyplot is an interactive way to use matplotlib)
To save-
plt.savefig(‘filename.png’)
Different type of graphs:
1. Line
2. Bar
3. Histogram
4. Scatter
5. Pie
Line graph
plt.plot()
plt.title() - show the title
Bar graph
plt.bar() - vertical bar graph
plt.barh() - Horizontal bar graph
__________________________________________________
Histogram
plt.hist()
Scatter Plot
plt.scatter()
Pie Chart
plt.pie()
__________________________________________________
14.2 Seaborn:
Seaborn library in python is used for data visualization. It is a high level
interface for drawing/plotting graphs.
Installation:
pip install seaborn
Import:
import seaborn as sns
__________________________________________________
14.3 Plotting:
A) Statistical Relationship (Numerical vs Numerical):
Understanding the relationship between the numerical variables and how, in
turn, these relationships depend on other variables is called Statistical
Analysis.
Function used - sns.replot()
By default it is scatter plot
Example-
sns.replot(x=’col1’,y=’col2’,data=dataframe,hue=’‘
,size=’‘,row=’‘,col=’‘)
Hue is for color, size is for number of size.
B) Categorical Relationship (Categorical vs Numerical):

Function used- sns.catplot()
It is figure level function like replot() and has many axes level functions
such as:
Scatter plot (default) - stripplot() and swarmplot()
stripplot() or catplot(x=’col1’, y=’col2’,kind = “strip”)
Data is plotted in the form of strips with jitter.
__________________________________________________
swarmplot() or catplot(x=’col1’, y=’col2’, kind=’swarm’)
To prevent the overlapping.
Distribution plot- Distribution plot used with large dataset for better data
visualization.
1.boxplot() or catplot(x=’col1’, y=’col2’,kind = “box”)
2.boxenplot() or catplot(x=’col1’,y=’col2’,kind=’boxen’)
3.violinplot() or catplot(x=’col1’, y=’col2’, kind=’violin’)
Estimate plot- barplot() or catplot(x=’col1’, y=’col2’,kind = “bar”) - Data
is plotted in the form of bars.
C) Distribution of data:
For Univariate analysis- sns.displot()
For Bivariate analysis- sns.jointplot()
__________________________________________________
CHAPTER 15
API
15.1 Application Program Interface
An application program interface (API) is a set of routines, protocols, and
tools for building software applications. Basically, an API specifies how we
interact with other computers over the internet. A good API makes it easier
to develop a program by providing all the building blocks. A programmer
then puts the blocks together.
Popular API Examples
1. Google Maps API
2. YouTube APIs
3. Flickr API
4. Twitter APIs
5. Amazon Product Advertising API
__________________________________________________
15.2 How To Interact With API
Most modern API’s are HTTP based and can be accessed using a GET or
PUT request to the base url of the API website. Generally these APIs
require a secret token for user authentication and input data with correct
variable name and value. In python this data can be serialised using python
dictionaries.
These requests are sent in python using the requests library.
Installing requests-
!pip install requests
Importing the library-
import requests
Sending request-
response = requests.<GET|POST>
(url_name,data_dictionary)
Extracting Data-
data = response.text
jsonData = response.json()
__________________________________________________
CHAPTER 16
Zerodha API
16.1 Getting Started With Kite Connect
Kite Connect is Zerodha’s API for web based trading. It is used to automate
trading strategies based on user’s requirements. Zerodha is one of the
pioneers in API trading in India. Kite connect is a general API which can be
manipulated using various languages like Python, Java, Ruby etc. But in
this course we will be working on python to implement our strategies using
Zerodha’s Kite Connect API.
To start working with Kite Connect we have to first create a developers
account on Zerodha’s platform - https://developers.kite.trade/signup
We also have a list of classes which are present in KiteConnect SDK, they
can be used as a reference while building any trading code. The link for
KiteConnect python SDK is https://kite.trade/docs/pykiteconnect/v3/
Although we don't need to go through the entire documentation right now
because that is what we will be covering in the further chapters but, to have
a full knowledge of what is possible through this API one can always refer
to it.
__________________________________________________
16.2 Create A Trading Application
Kite connect offers a feature to have multiple sets of strategies being
implemented at the same time through the same account but in isolation
from each other. Hence to start building one of them we need to create a
Trading Application on Kite Connect.
Before you can start building the Trading Application you need to have a
developer account first. If you don't have one then refer the earlier modules
as to how to create one. After creating a developer account you need to log
in to it.
Once it is done and you are on the Kite Connect Dashboard, you will see a
“Create New App button on the top right part of your screen (Click it).
Then you will have an option to create a Connect account and a Publisher
(Free account). For trading you have to go with the paid Connect Account.
Next fill in your App Name, Zerodha Client ID, App Icon(optional) and a
Description.
Redirect URL is the website where once you authenticate, Zerodha will
send your request token. If you are a developer and know how to configure
it then that's good. But if you don't then you don't need to worry. Just put
https://127.0.0.1 in it.
Postback URL is simply a tracking mechanism to get information about the
requests you make to the Kite Server. So if you don't know how to
configure it then leave it empty for now.
__________________________________________________
Once the App is created, you can click on it to edit it’s settings and to
retrieve your API key and API secret which is important for the next part.
Also you can enable the Historical API from there if it isn’t already enabled
to get Historical data from Kite Connect API.
__________________________________________________
16.3 Installing KiteConnect Library
kiteconnect is the python wrapper of Kite Connect API. You can install by
running this code in you command line -
pip install --upgrade kiteconnect
__________________________________________________
16.4 Access Token Generation
Access token is used to authenticate requests made to the Kite Connect API.
Retrieving an access token is a multi step process. It requires several other
inputs to be retrieved, which include -
1. api_key
2. api_secret
3. user_id
4. password
5. pin
6. request_token
Api Key and Api Secret are retrieved from the edit section of the Zerodha
app after you have signed in, as we did in the previous modules. User
Id,password and PIN are the ones which you use for logging into your
developers account.
Request Token is generated using the first five elements and using it along
with the others we will then generate the Access Token. Although you can
keep using the request token for all your request authentications, the
problem with it is that it expires very quickly and then you have to
complete the entire tedious procedure of retrieving the new request token
for your requests to
__________________________________________________
the Kite Connect API. Hence to solve this problem, as soon as you get your
request token you must generate your access token using it which doesn't
expire for a long time.
Importing Libraries -
from kiteconnect import KiteConnect
from selenium import webdriver from
kiteconnect import KiteConnect
from selenium import webdriver
import time
import os
Selenium is the library which we will be using to automate our work like
authentication, key retrieval etc. The time library as the name suggests is
used for manipulating time processes using python.
Os library is used to manipulate the operating system using python.
def autologin():
token_path = "api_key.txt"
key_secret =
open(token_path,'r').read().split()
kite = KiteConnect(api_key=key_secret[0])
service =
webdriver.chrome.service.Service('./chromedriver')
service.start()
options = webdriver.ChromeOptions()
options.add_argument('--headless')
__________________________________________________
options = options.to_capabilities()
driver =
webdriver.Remote(service.service_url, options)
driver.get(kite.login_url())
driver.implicitly_wait(10)
username=driver.find_element_by_xpath('/html/
body/div[1]/div/div[2]
/div[1]/div/div/div[2]/form/div[1]/input')
password=driver.find_element_by_xpath('/html/
body/div[1]/div/div[2]
/div[1]/div/div/div[2]/form/div[2]/input')
username.send_keys(key_secret[2])
password.send_keys(key_secret[3])
driver.find_element_by_xpath('/html/body/div[
1]/div/div[2]/div[1]/d
iv/div/div[2]/form/div[4]/button').click()
pin=driver.find_element_by_xpath('/html/body/
div[1]/div/div[2]/div[
1]/div/div/div[2]/form/div[2]/div/input')
pin.send_keys(key_secret[4])
driver.find_element_by_xpath('/html/body/div[
1]/div/div[2]/div[1]/d
iv/div/div[2]/form/div[3]/button').click()
time.sleep(10)
request_token=driver.current_url.split('=')
[1].split('&action')[0]
with open('request_token.txt', 'w') as
the_file:
the_file.write(request_token)
driver.quit()
__________________________________________________
This code is used to automate the authentication process and to retrieve the
request token. We start by retrieving the key secret which you have saved
inside api_token.txt file in the same folder as this code. We then create a
KiteConnect object which we will use to interact with the kite connect API.
To start the authentication process we create a selenium webdriver object
for chrome, pass the location of the webdriver file, set it to be headless
(which means that the entire process will take place in the background) and
begin it’s service. Once the service is up and running, we request the login
url from the KiteConnect object, redirect to that url and the username and
password field on that page. Once this is done, selenium passes your
username and password to it, finds the submit button, clicks it and redirects
to the page asking for the pin. This process is then repeated for PIN. Once
the authentication is complete, your Request Token comes as a part of your
redirect url which is then retrieved from it and saved to a file name
'request_token.txt'.
Although this process takes place in the background, knowing these steps is
important so that in case one day Zerodha changes some aspects of the
login procedure then you can adjust your code accordingly. But for now you
can use this code to retrieve your Request Token.
__________________________________________________
Setting Up Environment Variables

autologin()
request_token =
open("request_token.txt",'r').read()
key_secret=open("api_key.txt",'r')
key_secret=read().split( )
The autologin function which we earlier prepared is of no use unless it is
called. Hence we call that function and create a 'request_token.txt' file
containing our Request Token. We then read the request token and Key
Secret from their corresponding files.
Retrieving Access Token
autologin()
request_token =
open("request_token.txt",'r').read()
key_secret =
open("api_key.txt",'r').read().split()
Everytime we need to communicate with the Kite Connect API we need a
KiteConnect object, but we don't need to create one every time. Although in
this case we created our KiteConnect object inside a function, so we are
creating a new KiteConnect object outside it to be used further. We pass the
Key Secret to create the KiteConnect object and then use this object to
generate a session using Request Token and Key Secret. Once the session is
created, we can retrieve our Access Token from it and save it in a file to be
used later to interact with the Kite Connect API.
__________________________________________________
16.5 Getting Historical Data
The term Historical data refers to the data for the time which has gone.
Explaining it with the help of an example, if the market is open the time
now being 11:00 AM. The data which we can fetch from historical API is
till 11:00 AM.
It can also be used while we are computing values of certain technical
indicators as it eradicates the need for storing tick data. It helps us with
accurate resampled data even in case our internet gets disconnected as the
database is maintained on Zerodha’s side.The code for fetching historical
data is as follows:-
def fetchOHLC(ticker,interval,duration):
"""
extracts historical data and outputs in the
form of dataframe
"""
instrument =
instrumentLookup(instrument_df,ticker)
data = pd.DataFrame( kite.historical_data
(instrument, dt.date.today() -
dt.timedelta(duration), dt.date.today(),interval))
data.set_index("date",inplace=True)
return data
fetchOHLC("BANKNIFTY20SEPFUT","5minute")
__________________________________________________
16.6 Fetching Instrument Token
Instrument token as the name suggests is a token used instead of stock name
to avoid mistakes while typing the stock name. It is provided and
maintained by Zerodha, the instrument tokens are updated on a daily basis
for NFO scripts as they expire every week.
We need to fetch instrument tokens from kite before starting our algorithm.
The command for fetching instrument token is as follows:-
instrument_dump =
kite.instruments("exchange_name")
Example to find instrument token of a particular stocks is given below

instrument_dump = kite.instruments("NFO")
instrument_df = pd.DataFrame(instrument_dump)
def instrumentLookup(symbol):
return
instrument_df[instrument_df.tradingsymbol==symb
ol].instrument_token.values[0]
instrumentLookup(‘RELIANCE’)
__________________________________________________
Output:
11577090
__________________________________________________
16.7 Streaming Tick Data
Kite Connect uses a KiteTicker object to connect to zerodha’s socket under
the hood. We need to initialize the KiteTicker objects using API_KEY and
ACCESS_TOKEN. After initialization we need to set various functions
with predefined number of inputs to the object to be executed at various
events, during and after socket connection. These functions include -
1.
on_ticks(ws, ticks) - It is executed when the live data is
fetched by the socket.
○ ws - It is the reference to the KiteTicker object

○ ticks - It contains all the data that you receive from the
socket
2. on_close(ws, code, reason) - It is triggered when connection

to the socket is closed. Decisions to reconnect or not can be
taken inside this function.

○ code - It is the status code received from the socket as to
why the connection was closed.
○ reason - Readable reason for connection closing.
3. on_error(ws, code, reason) - This function is executed when

connection is closed with an error, you can choose to log it
or program it to move further cleanly.
__________________________________________________

○ code - It is the status code received from the socket as to
why the connection was closed.
○ reason - Readable reason for connection closing.
4. on_connect(ws, response) - This is primarily the first
function which is executed after a connection is established
with the socket. The symbols that you need to get live data
from need to be called using the subscribe function inside
this function.

○ response - Response received from server on successful
connection.
5. on_message(ws, payload, is_binary) - This is an optional

function which is used to handle messages received from the
server.

○ payload - Raw response from the server, received either in
binary or non binary form based on the is_binary value.
○ is_binary - Boolean to check if response(payload) is
binary type.
6. on_reconnect(ws, attempts_count) - It is another optional

function which describes the reconnection of the socket
connection.
__________________________________________________

○ attempts_count - Current reconnect attempt number.
7. on_noreconnect(ws) - Reverse of on_reconnect function, i.e.

it is executed when reconnection attempts exceed
reconnect_tries.
8. on_order_update(ws, data) - This is triggered when there is

an order update for the connected user. Although this
function is also optional, yet it can be used to prevent calling
the get status function to check whether or not the order has
been updated.

○ data - Response of the server when there is an order update
for the connected user.
__________________________________________________
Sample Socket Code -

# Socket object of kiteconnect
from kiteconnect import KiteTicker
from pprint import pprint
import time
# Initialise
kws = KiteTicker("your_api_key", "your_access_token")
def on_ticks(ws, ticks):

# Callback to receive ticks (live socket data).
pprint(ticks)
def on_connect(ws, response):
# Callback on successful connection.
# Subscribe to a list of
instrument_tokens
# (RELIANCE and ACC here)
ws.subscribe([5633, 738561])
# Set RELIANCE to tick in `full` mode
i.e. to get more data
# for that instrument_tokens
ws.set_mode(ws.MODE_FULL, [738561])
def on_close(ws, code, reason):
# On connection close stop the event
loop.# Reconnection will not happen after
executing
ws.stop()`
__________________________________________________
try:
print(f'Server Error {code} : {reason}')
time.sleep(2)
except KeyboardInterrupt:
ws.stop()
# Assign the callbacks.
kws.on_ticks = on_ticks
kws.on_connect = on_connect
kws.on_close = on_close
# Infinite loop on the main thread.
# Nothing after this will run.
kws.connect()
__________________________________________________
16.8 Placing Order
Orders can be placed using the KiteConnect object using the place_order
function. The place_order function takes several inputs based on the order
you want to place and returns an order id, if the order has been placed. The
syntax of place_order is -
place_order( variety, exchange, tradingsymbol, transaction_type, quantity,
product, order_type, price=None, validity=None, disclosed_quantity=None,
trigger_price=None, squareoff=None, stoploss=None,
trailing_stoploss=None, tag=None)
Variety
VARIETY_AMO
VARIETY_BO
VARIETY_CO
VARIETY_REGULAR
Exchange
EXCHANGE_BFO
EXCHANGE_BSE
EXCHANGE_CDS
EXCHANGE_MCX
EXCHANGE_NFO
EXCHANGE_NSE
__________________________________________________
Trading Symbol - Retrieve using the instruments() function

Transaction Type
TRANSACTION_TYPE_BUY
TRANSACTION_TYPE_SELL
Product
PRODUCT_BO
PRODUCT_CNC
PRODUCT_CO
PRODUCT_MIS
PRODUCT_NRML
Order Type
ORDER_TYPE_LIMIT
ORDER_TYPE_MARKET
ORDER_TYPE_SL
ORDER_TYPE_SLM
Validity
VALIDITY_DAY
VALIDITY_IOC
Tag - (Optional) String used to represent a request to the server and is
received in the response in order to create asynchronous behaviour possible
if applicable.
__________________________________________________
16.9 Cancel Order
Cancel order function takes order id and variety as input of the order you
want to cancel. Order ID can be retrieved after you place an order or
through the orders book.
kite.cancel_order(variety, order_id)
__________________________________________________
16.10 Order History
Order history of all orders can be retrieved using the orders function which
contains the status including order id, order status etc for all your orders of
the day.
kite.orders()
Order details of a specific order can be retrieved using the order_history
function which takes the order id of which you want the details for in this
function.
kite.order_history(‘order_id’)
__________________________________________________
CHAPTER 17
Technical Indicators & Price Action

techniques
As the name suggests, we used some techniques to derive some meaningful

inferences from stock market data. There are various types of indicators
which are namely Momentum based, volatility based, mean reversion
based.
Technical Indicators are mathematical calculations based on historical price
volume or open interest information to predict asset price direction. The
important part of technical analysis is based on analyzing trends, chart
patterns, etc.
Popular technical indicators include:
● MACD: Moving Average Convergence Divergence
● Bollinger Bands
● Average True Range(ATR)
● RSI: Relative Strength Index
● ADX: Average Directional Index
● Supertrend
● Chaikin Money Flow Index(CMF)
● Ichimoku Cloud
● On-Balance Volume(OBV)
In this section, we would be covering how to code technical indicators
using talib library.Installing pyti is pretty simple. It can be installed by the
following command:-
!pip install talib
__________________________________________________
17.1 Import Technical Indicator From Library
The github repository link for talib is https://github.com/mrjbq7/ta-
lib/tree/master/talib
__________________________________________________
17.2 Coding Technical Indicators
17.2.1 MACD
The Moving Average Convergence/Divergence oscillator (MACD) is one of
the simplest and most effective momentum indicators. The MACD turns
two trend-following indicators, moving averages into a momentum
oscillator by subtracting the longer moving average(26) from the shorter
one(12).
A signal line is also calculated, which is again a moving average (typically
9 periods) of the MACD line calculated as per the above step.
The MACD line cutting signal line from below signals a bullish period and
the former cutting the latter from above signals a bearish period. This is
called a crossover strategy.
In python:
#using talib module
from talib import MACD
macd,macdsignal,macdhist= MACD(df['close'],
fastperiod=12, slowperiod=26,signalperiod=9)
# another implementation
def MACD(DF,a,b,c):
"""function to calculate MACD
typical values a(fast
MA)=12;b(slow A)=26;c(si
gnal line MA window) =9
"""
__________________________________________________
df = DF.copy()
df["MA_Fast"]=df["close"].ewm(span=a,
min_periods=a).mean()
df["MA_Slow"]=df["close"].ewm(span=b,
min_periods=b).mean()
df["MACD"]=df["MA_Fast"]-df["MA_Slow"]
df["Signal"]=df["MACD"].ewm(span=c,min_peri
ods=c).mean()
df.dropna(inplace=True)
return df
17.2.2 Bollinger Bands

It is a volatility based indicator. It comprises two lines plotted n (n is
typically 2) standard deviations from an m period simple moving average
line (m is typically 20). As volatility increases, the band widens.
In python:
#using talib module
from talib import BBANDS
upperband, middleband, lowerband =
BBANDS(df['close'], timeperiod=5, nbdevup=2,
nbdevdn=2, matype=0)
def bollBnd(DF,n):
df = DF.copy()
df["MA"]= df['close'].rolling(n).mean()
#df["MA"]=
df['close'].ewm(span=n,min_periods=n).mean()
__________________________________________________
df["BB_up"]=df["MA"]+2*
df['close'].rolling(n).std(ddof=0)
#ddof=0 is required since we want to take
the standard deviation of the population and not
sample
df["BB_dn"]=df["MA"]-2*df['close'].
rolling(n).std(ddof=0)
#ddof=0 is required since we want to take
the standard deviation of the population and not
sample
df["BB_width"] = df["BB_up"] - df["BB_dn"]
df.dropna(inplace=True)
return df
bollBnd(df,10)
17.2.3 ATR(Average True Return)

It is a volatility based indicator. It takes into account the market movement
of each day in either direction and averaging them out. It focuses on the
total price movement and conveys how vividly the market is swinging as it
moves.
Traders generally use Bollinger Bands and ATR in conjunction as they
approach volatility differently and are complementary.
__________________________________________________
In python:
#using talib module
from talib import ATR
real = ATR(df['high'], df['low'],
df['close'], timeperiod=14)
def atr(DF,n):
"""
function to calculate True Range and
Average True Range
"""
df = DF.copy()
df['H-L']=abs(df['high']-df['low'])
df['H-PC']=abs(df['high']-
df['close'].shift(1))
df['L-PC']=abs(df['low']-
df['close'].shift(1))
df['TR']=df[['H-L','H-PC','L-
PC']].max(axis=1,skipna=False)
df['ATR'] =
df['TR'].ewm(com=n,min_periods=n).mean()
return df['ATR']
atr(df,10)
__________________________________________________
17.2.4 Relative Strength Index

RSI is a momentum oscillator that measures the speed and change of price
movements. RSI value oscillates between 0 and 100 with values above 70,
indicating that the asset has now reached overbought territory. Values below
30 signify oversold territory.
In python:
#using talib module
from talib import RSI
real = RSI(df['close'], timeperiod=14)
def rsi(df, n):
delta = df["close"].diff().dropna()
u = delta * 0
d = u.copy()
u[delta > 0] = delta[delta > 0]
d[delta < 0] = -delta[delta < 0]
u[u.index[n-1]] = np.mean( u[:n])
#first value is average of gains
u = u.drop(u.index[:(n-1)])
d[d.index[n-1]] = np.mean( d[:n])
d = d.drop(d.index[:(n-1)])
rs=u.ewm(com=n,min_periods=n).mean()
/d.ewm(com=n, min_periods=n).mean()
return 100 - 100 / (1+rs)
rsi(df,10)
__________________________________________________
17.2.5 Average Directional Index

It is a way of measuring the strength of underlying trends. Its values range
from 0 to 100 and quantify the strength of a trend as per below:
● 0-25 absent or weak trend
● 25-50 strong trend
● 50-75 very strong trend
● 75-100 extremely strong trend
ADX is non-directional, meaning the ADX value makes no inference about
the direction of the trend but only the strength of the trend. The calculation
involves finding both positive and negative directional movement and then
calculating the smoothed average difference of these.
In python:
#using talib module
from talib import ADX
real=ADX(df['high'],df['low'], df['close'],
timeperiod=14)
#another implementation
def adx(DF,n):
"function to calculate ADX"
df2 = DF.copy()
df2['H-L']=abs(df2['high']-df2['low'])
df2['H-PC']=abs(df2['high']-
df2['close'].shift(1))
__________________________________________________
df2['L-PC']=abs(df2['low']-
df2['close'].shift(1))
df2['TR']=df2[['H-L','H-PC','L-
PC']].max(axis=1,skipna=False)
df2['DMplus']=np.where((df2['high']-
df2['high'].shift(1))>(df2['low'].shift(1)-
df2['low']), df2['high'] -
df2['high'].shift(1),0)
df2['D
Mplus']=np.where(df2['DMplus']
<0,0,df2['DMplus'])
df2['DMminus']=np.where((df2['low'].shif
t(1)-df2['low'])>(df2['high']-
df2['high'].shift(1)),df2['low'].shift(1
)-df2['low'],0)
df2['DMminus']=np.where(df2['DMminus']
<0,0,df2['DMminus'])
TRn = []
DMplusN = []
DMminusN = []
TR = df2['TR'].tolist()
DMplus = df2['DMplus'].tolist()
DMminus = df2['DMminus'].tolist()
for i in range(len(df2)):
if i < n:
TRn.append(np.NaN)
DMplusN.append(np.NaN)
__________________________________________________
DMminusN.append(np.NaN)
if i == n:
Rn.append(df2['TR'].rolling(n).sum().tol
ist()[n])
DMplusN.append(df2['DMplus'].rolling
(n).sum().tolist()[n])
DMminusN.append(df2['DMminus'].rolli
ng(n).sum().tolist()[n])
elif i > n:
TRn.append(TRn[i-1]- (TRn[i-
1]/n) + TR[i])
DMplusN.append(DMplusN[i-1] -
(DMplusN[i-1]/n) +DMplus[i])
DMminusN.append(DMminusN[i-1] -
(DMminusN[i-1]/n) + DMminus[i])
df2['TRn'] = np.array(TRn)
df2['DMplusN']=np.array(DMplusN)
df2['DMminusN']=np.array(DMminusN)
df2['DIplusN']=100*
(df2['DMplusN']/df2['TRn'])
df2['DIminusN']=100*
(df2['DMminusN']/df2['TRn'])
df2['DIdiff']=abs(d2['DIplusN']-
df2['DIminusN'])
df2['DIsum']=df2['DIplusN']+df2['DIminusN']
df2['DX']=100*
(df2['DIdiff']/df2['DIsum'])
__________________________________________________
ADX = []
DX = df2['DX'].tolist()
for j in range(len(df2)):
if j < 2*n-1:
ADX.append(np.NaN)
elif j == 2*n-1:
ADX.append(df2['DX'][j-
n+1:j+1].mean())
elif j > 2*n-1:
ADX.append(((n-1)*ADX[j-1]
+ DX[j])/n)
df2['ADX']=np.array(ADX)
return df2['ADX']
adx(df,10)
__________________________________________________
17.2.6 Supertrend
As the name suggests, ‘Supertrend’ is a trend-following indicator just like
moving averages and MACD (moving average convergence divergence). It
is plotted on prices and their placement indicates the current trend.
The indicator is easy to use and gives an accurate reading about an ongoing
trend. It is constructed with two parameters, namely period and multiplier.
The default values used while constructing a super-indicator are 10 for
average true range or trading period and three for its multiplier.
The code consists of 3 modules the first two being EMA and ATR which
are required to compute Supertrend values.
In python:
def EMA(df, base, target, period,
alpha=False):
con= pd.concat([df[:period]
[base].rolling(window=period).mean(),
df[period:][base]])
if (alpha == True):
df[target] = con.ewm(alpha=1 / period,
adjust=False).mean()
__________________________________________________
else:
df[target] = con.ewm(span=period,
adjust=False).mean()
df[target].fillna(0, inplace=True)
return df
def ATR(df, period, ohlc=['open', 'high',
'low', 'close']):
atr = 'ATR_' + str(period)
if not 'TR' in df.columns:
df['h-l'] = df[ohlc[1]] - df[ohlc[2]]
df['h-yc'] = abs(df[ohlc[1]] -
df[ohlc[3]].shift())
df['l-yc'] = abs(df[ohlc[2]] -
df[ohlc[3]].shift())
df['TR'] = df[['h-l', 'h-yc', 'l-
yc']].max(axis=1)
df.drop(['h-l', 'h-yc', 'l-yc'],
inplace=True, axis=1)
EMA(df, 'TR', atr, period, alpha=True)

return df
def SuperTrend(df, period, multiplier, ohlc=

['open', 'high', 'low', 'close']):
ATR(df, period, ohlc=ohlc)

atr = 'ATR_' + str(period)
st = 'ST' #+ str(period) + '_' +
str(multiplier)
__________________________________________________
stx = 'STX' # + str(period) + '_' +

str(multiplier)
# Compute basic upper and lower bands
df['basic_ub'] = (df[ohlc[1]] +
df[ohlc[2]]) / 2 + multiplier
* df[atr]
df['basic_lb'] = (df[ohlc[1]] +
df[ohlc[2]]) / 2 - multiplier * df[atr]
# Compute final upper and lower bands
df['final_ub'] = 0.00
df['final_lb'] = 0.00
for i in range(period, len(df)):
df['final_ub'].iat[i]=
df['basic_ub'].iat[i] if df['basic_ub'].iat[i] <
df['final_ub'].iat[i-1] or df[ohlc[3]].iat[i - 1]
> df['final_ub'].iat[i - 1]
else df['final_ub'].iat[i - 1]
df['final_lb'].iat[i]=
df['basic_lb'].iat[i] if df['basic_lb'].iat[i] >
df['final_lb'].iat[i - 1] or df[ohlc[3]].iat[i -
1] < df['final_lb'].iat[i - 1]
else df['final_lb'].iat[i - 1]
__________________________________________________
# Set the Supertrend value

df[st] = 0.00
for i in range(period, len(df)):
df[st].iat[i] = df['final_ub'].iat[i] if
df[st].iat[i - 1] == df['final_ub'].iat[i - 1]
and df[ohlc[3]].iat[i] <= df['final_ub'].iat[i]
else df['final_lb'].iat[i] if df[st].iat[i-
1]==df['final_ub'].iat[i - 1] and
df[ohlc[3]].iat[i]>df['final_ub'].iat[i] else
df['final_lb'].iat[i] if
df[st].iat[i -1] ==
df['final_lb'].iat[i - 1] and df[ohlc[3]].iat[i]
>= \df['final_lb'].iat[i] else
\df['final_ub'].iat[i] if df[st].iat[i - 1] ==
df['final_lb'].iat[i - 1]
and df[ohlc[3]].iat[i] <
\df['final_lb'].iat[i] else 0.00
# Mark the trend direction up/down
df[stx] = np.where((df[st] > 0.00),
np.where((df[ohlc[3]] < df[st]), 'down',
'up'), np.NaN)
# Remove basic and final bands from the
columns
df.drop(['basic_ub', 'basic_lb',
'final_ub', 'final_lb'], inplace=True, axis=1)
df.fillna(0, inplace=True)
return df
SuperTrend(df,7,3)
__________________________________________________
17.2.7 Chaikin Money Flow (CMF)

Chaikin Money Flow (CMF) developed by Marc Chaikin is a volume-
weighted average of accumulation and distribution over a specified period.
The standard CMF period is 21 days. The principle behind the Chaikin
Money Flow is the nearer the closing price is to the high, the more
accumulation has taken place. Conversely, the nearer the closing price is to
the low, the more distribution has taken place. If the price action
consistently closes above the bar's midpoint on increasing volume, the
Chaikin Money Flow will be positive. Conversely, if the price action
consistently closes below the bar's midpoint on increasing volume, the
Chaikin Money Flow will be a negative value.
In python:
def chaikin_money_flow(close_data, high_data,
low_data, volume, period):
"""
Chaikin Money Flow Formula:
CMF = SUM[(((Cn - Ln) - (Hn - Cn)) / (Hn -
Ln)) * V] / SUM(Vn)
"""
catch_errors.check_for_input_len_diff(
close_data, high_data, low_data, volume)
catch_errors.check_for_period_error(close_d
ata, period)
__________________________________________________
close_data = np.array(close_data)
high_data = np.array(high_data)
low_data = np.array(low_data)
volume = np.array(volume)
cmf=[sum((((close_data[idx+1-period:idx+1]-
low_data[idx+1-period:idx+1])-(high_data[idx+1-
period:idx+1]-
close_data[idx+1- period:idx+1]))/(hi
gh_data[idx+1-period:idx+1]-low_data[idx+1-
period:idx+1]))*volume[idx+1-
period:idx+1])/sum(volume[idx+1- peri
od:idx+1])for idx in range(period-1,
len(close_data))]
cmf=fill_for_noncomputable_vals(close_data,
cmf)
return cmf
17.2.8 Ichimoku Cloud

The Ichimoku Cloud is a collection of technical indicators that show
support and resistance levels, as well as momentum and trend direction. It
does this by taking multiple averages and plotting them on the chart. It also
uses these figures to compute a "cloud" which attempts to forecast where
the price may find support or resistance in the future.
__________________________________________________
def conversion_base_line_helper(data, period):

"" The only real difference between
TenkanSen and KijunSen is the period value"""
catch_errors.check_for_period_error(data,
period)
cblh = [(np.max(data[idx+1-period:idx+1])
+np.min(data[idx+1- period:idx+1])) / 2 for idx
in range(period-1, len(data))]
cblh = fill_for_noncomputable_vals(data,
cblh)
return cblh
def tenkansen(data, period=9):

""" TenkanSen (Conversion Line)
Formula:
(H + L) / 2 :: default period=9
"""
ts = conversion_base_line_helper(data,
period)
return ts
def kijunsen(data, period=26):

"""
KijunSen (Base Line) Formula:
(H + L) / 2 :: default period=26
"""
ks = conversion_base_line_helper(data,
period)
return ks
__________________________________________________
def chiku_span(data):
"""
Chiku Span (Lagging Span)
Formula: Close shifted back 26 bars
"""
cs = data[25::]
return cs
def senkou_a(data):
"""
Senkou A (Leading Span A) Formula:
(TenkanSen + KijunSen) / 2 :: Shift Forward
26 bars
"""
sa = (tenkansen(data) + kijunsen(data)) / 2
# shift forward
shift_by = np.repeat(np.nan, 26)
sa = np.append(shift_by, sa)
return sa
__________________________________________________
def senkou_b(data, period=52):
"""
Senkou B (Leading Span B)
Formula: (H + L) / 2 :: default period=52
:: shifted forward 26 bars
"""
sb = conversion_base_line_helper(data,
period)
shift_by = np.repeat(np.nan, 26)
sb = np.append(shift_by, sb)
return sb
17.2.9 On Balance Volume

On-balance volume (OBV) is a technical trading momentum indicator that
uses volume flow to predict changes in stock price. Joseph Granville first
developed the OBV metric in the 1963 book Granville's New Key to Stock
Market Profits.
Granville believed that volume was the key force behind markets and
designed OBV to project when major moves in the markets would occur
based on volume changes.
__________________________________________________
def on_balance_volume(close_data, volume):
"""
On Balance Volume.
Formula:
start = 1
if CLOSEt > CLOSEt-1
obv = obvt-1 + volumet
elif CLOSEt < CLOSEt-1
obv = obvt-1 - volumet
elif CLOSEt == CLOSTt-1
obv = obvt-1
"""
catch_errors.check_for_input_len_diff(close
_data, volume)
obv = np.zeros(len(volume))
obv[0] = 1
for idx in range(1, len(obv)):
if close_data[idx] > close_data[idx-1]:
obv[idx] = obv[idx-1] + volume[idx]
elif close_data[idx] < close_data[idx-1]:
obv[idx] = obv[idx-1] - volume[idx]
elif close_data[idx] == close_data[idx-
1]:
obv[idx] = obv[idx-1]
return obv
__________________________________________________
17.3 Price Action Techniques
Price action is a branch of technical analysis concerning price bar patterns.
This trading philosophy asset price action with chart patterns. The key
terms in these concepts are Support, Resistance, Higher Highs, Lower
Lows, Swing Trading, Momentum trading etc (Google them if you already
don’t know about them). Price action based indicators predict the price
action.
Some popular price action based candlestick patterns include:
● Doji
● Hammer
● Shooting star
● Marubozu
17.3.1 Doji
A candle in which open and close are apparently the same i.e. length of the
candle is zero is called a doji. It looks like a cross or an inverted cross, the
size of the wicks is generally irrelevant.
Doji represents uncertainty on both the buyers as well as sellers. It can
signal both trend reversal or breakout on the pattern in which it occurs.
In python:
#using talib module
from talib import CDLDOJI
integer = CDLDOJI(open, high, low, close)
__________________________________________________
def doji(ohlc_df):
"""
returns dataframe with doji candle col
umn
"""
df = ohlc_df.copy()
avg_candle_size = abs(df["close"] -
df["open"]).median()
df["doji"] = abs(df["close"] - df["open"])
<= (0.05 * avg_candle_size)
return df
17.3.2 Hammer
A candle in which the lower wick is at least twice the size of the body.
Body can be red or green (bearish or bullish). Upper wick should be small
or non-existent.
This candle is viewed as a bullish reversal candlestick when occurring
during a downtrend.
In python:
#using talib module
from talib import CDLHAMMER
integer = CDLHAMMER(open, high, low, close)
def hammer(ohlc_df):
df = ohlc_df.copy()
__________________________________________________
df["hammer"]=(((df["high"]- df["low"]) >3*
(df["open"]-df["close"]))&((df["close"] -
df["low"])/(0.001+df["high"]-df["low"])>0.6) &
((df["open"]-df["low"])/(.001 + df["high"] -
df["low"])>0.6))&(abs(df["close"]- df["open"] ) >
0.1* (df["high"] - df["low"]))
return df
hammer(df)
17.3.3 Shooting Star

A candle in which the upper wick is at least twice the size of the body, just
opposite of the hammer. Body can be red or green (red is preferred). Lower
wick should be small or non existent.
This candle is viewed as a bearish reversal candlestick when occurring
during an uptrend.
In python:
#using talib module
from talib import CDLSHOOTINGSTAR
integer = CDLSHOOTINGSTAR(open, high, low, close)
def shooting_star(ohlc_df):
"""
returns dataframe with shooting star
candle column
"""
df = ohlc_df.copy()
__________________________________________________
df["sstar"] = (((df["high"] - df["low"])>3*
(df["open"] - df["close"])) & ((df["high"] -
df["close"])/(.001 + df["high"] - df["low"]) >
0.6) & ((df["high"] -
df["open"])/(.001 + df["high"] - df["low"]) >
0.6)) & (abs(df["close"] -
df["open"]) > 0.1* (df["high"] - df["low"]))
return df
shooting_star(df)
17.3.4 Marubozu
A candle which is long and sturdy with a very small or non existent wick.
Body can be red or green with green signifying bulls in complete control
whereas red signifies bears to have complete control.
This candle can signal both breakout or trend reversal depending on where
it occurs in the chart.
In python:
#using talib module
#using talib module
from talib import CDLMARUBOZU
integer = CDLMARUBOZU(df['open'],
df['high'], df['low'], df['close'])
__________________________________________________
def maru_bozu(ohlc_df):
"""returns dataframe with maru bozu candle
column"""
df = ohlc_df.copy()
avg_candle_size = abs(df["close"] -
df["open"]).median()
df["h-c"] = df["high"]-df["close"]
df["l-o"] = df["low"]-df["open"]
df["h-o"] = df["high"]-df["open"]
df["l-c"] = df["low"]-df["close"]
df["maru_bozu"] = np.where((df["close"] -
df["open"]>2*avg_candle_size)&(df[["h-c","l-
o"]].max(axis=1)
<0.005*avg_candle_size),"maru_bozu_green",np.where
((df["open"]- df[" close "] >
2*avg_candle_size) & (abs(df[["h-o","l-
c"]]).max(axis=1)<0.005* avg_candle_size
),"maru_bozu_red",False))
df.drop(["h-c","l-o","h-o","l-
c"],axis=1,inplace=True)
return df
maru_bozu(df)
__________________________________________________
CHAPTER 18
Handling Streaming Tick Data
What we receive from any broker is tick data. Tick data basically
corresponds to any transaction made by buyer and seller.
Zerodha generally streams 1-2 ticks per second. These ticks are useful when
we are into HFT, but we need to re-sample it for our use.
Re-sampling is the process of converting granular data into a higher time
frame by storing them in a database and converting it into the timeframe we
require.
__________________________________________________
18.1 Streaming Data To CSV
Live data for any stock is retrieved from zerodha using sockets. We can
stream live data using Zerodha’s KiteTicker object. While streaming the
data we can store all ticks for all tokens and store it in a dictionary. After
the market closes or when the current time exceeds the endtime of the code
then we can convert this dictionary into pandas DataFrame and save them
into separate csv files containing time stamps and their corresponding last
traded price at that moment.
__________________________________________________
18.2 Converting Ticks To Candles

Tick data that we receive from the socket is often not used as is, but it needs
to be converted into candle data to determine OHLC and then be used for
further calculations. The easiest way to convert this tick data into candle
data is to store all the ltp values during the candle duration and once that
duration is over then we can convert all the last traded prices into open,
high, low and close; then we can finally discard the old ltp data and start
recording new data for the next candle.
# importing necessary modules
from selenium.webdriver.support.ui import
WebDriverWait
from selenium.common.exceptions import
TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import
expected_conditions as EC
import datetime
import pandas as pd
import time
from furl import furl
__________________________________________________
# class for single instrument data

class pocket:
def __init__(self,instrumentToken):
self.instrumentToken = instrumentToken
self.ltp = []
self.open = []
self.high = []
self.low = []
self.close = []
self.timeStamp = []
self.newData = 0
# Function to convert ltp data to ohlc
def ohlc(self):
if(self.ltp):
self.timeStamp.append(datetime.datetime.now()
)
self.open.append(self.ltp[0])
self.high.append(max(self.ltp))
self.low.append(min(self.ltp))
self.close.append(self.ltp[-1])
self.ltp = []
# Function to set ltp value
def setLtp(self,ltp):
# Function to get candles
dataframe
__________________________________________________
def getOhlc(self):
data = pd.DataFrame(data={
'timeStamp' : self.timeStamp,
'Open' : self.open,
'High' : self.high,
'Low' : self.low,
'Close' : self.close,
},columns=[
'timeStamp','Open','High','Low','Close'] )
data = data.set_index('timeStamp')
return data
# class to store all pocket data

class database:
def __init__(self, tokens,
startTime,delay):
self.pockets = {}
self.startTime = startTime
self.delay = delay
self.execution = startTime + delay
for token in tokens:
self.pockets[token] = pocket(token)
__________________________________________________
# Function to get pocket object by token

number
def getPocket(self,token):
return self.pockets[token]
# Setting ltp value based on token
def setVal(self,token,ltp):
self.getPocket(token).setLtp(ltp)
# Function to check of candle time is
executed
def checkCandle(self):
if(datetime.datetime.now()>self.execution):
self.execution += self.delay
for token in self.pockets:
self.pockets[token].ohlc()
# Set the new candle to be
available
self.pockets[token].newData
= 1
# Function to get candles dataframe of token
def getOhlc(self,token):
return
self.getPocket(token).getOhlc()
# Function to print dataframe of token
pocket
__________________________________________________
# if new candle is formed

def newCandle(self,token):
if(self.getPocket(token).newData):
self.getPocket(token).newData = 0
print('\n',token)
print(self.getOhlc(token))
# zerodha credentials
api_key = "your api_key"
api_secret = "your api_secret"
username = "your username"
password = "your password"
pin = "your pin"
request_token = "your request_token"
# function to wait for elements on page load
for selenium
def getCssElement( driver , cssSelector ):
return WebDriverWait( driver, 100
).until( EC.presence_of_element_located( (
By.CSS_SELECTOR, cssSelector ) ) )
#function to login to zerodha using selenium
def autologin():
kite = KiteConnect(api_key=api_key)
service =
__________________________________________________

service.start()
driver =
passwordField = getCssElement( driver
, "input[placeholder=Password]" )
passwordField.send_keys( password )
userNameField = getCssElement( driver

, "input[placeholder='User ID']" )
userNameField.send_keys( username )
loginButton = getCssElement( driver ,
"button[type=submit]" )
loginButton.click()
WebDriverWait(driver,
100).until(EC.presence_of_element_located((By.CLAS
S_NAME, 'twofa- value')))
pinField =
driver.find_element_by_class_name('twofa-
value').find_element_by_xpath(".//input[1]")
pinField.send_keys( pin )
__________________________________________________

loginButton.click()
while True:
try:
request_token=furl(driver.current_url).args['re
quest_token'].strip()
break
except:
time.sleep(1)
data =
kite.generate_session(request_token,
api_secret=api_secret)
with open('access_token.txt', 'w') as
file:
file.write(data["access_token"])
driver.quit()
autologin()
# retrieving access token from saved file
access_token_zerodha =
open("access_token.txt",'r').read()
# Tokens to subscribe
TOKENS = [738561, 5633]
__________________________________________________
# #creating kite connect object

# # setting access token ti kite connect
object
kite.set_access_token(access_token_zerodha)
# time at which code starts
STARTTIME = datetime.datetime.now()
#time at which code ends
ENDTIME
= datetime.datetime.now().replace(hour=1
5,minute=30,second=0)
#duration of a candle
DELAY =
datetime.timedelta(hours=0,minutes=1,seconds=0)
# Initiating Database
DATABASE = database(TOKENS,STARTTIME,DELAY)
#wai-ts till start time
while datetime.datetime.now()<STARTTIME:
pass
#kite ticker object to receive data from
zerodha
kws = KiteTicker(api_key,
access_token_zerodha)
#function to run when data is coming from
zerodha
__________________________________________________
global DATABASE
#creating new candles based on
execution time
#recording current data to database
for all tickers
DATABASE.checkCandle()
for x in ticks:
DATABASE.setVal(x['instrument_token'],x['last_pric
e'])
DATABASE.newCandle(x['instrument_token'])
#if current time is greater than
ENDTIME the stop the code
if(datetime.datetime.now()>ENDTIME):
print("Market is closed now...")
ws.stop()
#function to run when connection is
established to zerodha
# Callback on successful connect.
ws.subscribe(TOKENS)
#funcion to run on connection close

# On connection close stop the
main loop
__________________________________________________
# Reconnection will not happen after
executing `ws.stop()`
print(code)
print(reason)
ws.stop()
# Assign the callbacks.
# Infinite loop on the main thread. Nothing
after this will run.
# You have to use the pre-defined callbacks
to manage subscriptions.
kws.connect()
__________________________________________________
18.3 Place Order Based On Strategy
This code is used to place orders based on a simple strategy. The strategy
here is that if we get 3 continuous increasing highs then we buy that stock
and if we get 3 continuous decreasing lows then we sell that stock.
# importing necessary modules
from selenium.webdriver.support.ui import
WebDriverWait
from selenium.common.exceptions import
TimeoutException
from selenium.webdriver.common.by import By
from selenium.webdriver.support import
expected_conditions as EC
import datetime
import pandas as pd
import time
from furl import furl
# class for single instrument data
class pocket:
def __init__(self,instrumentToken):
self.instrumentToken = instrumentToken
__________________________________________________
self.ltp = []
self.open = []
self.high = []
self.low = []
self.close = []
self.timeStamp = []
self.newData = 0
# Function to convert ltp data to ohlc
def ohlc(self):
if(self.ltp):
self.timeStamp.append(datetime.datetime.now())
self.open.append(self.ltp[0])
self.high.append(max(self.ltp))
self.low.append(min(self.ltp))
self.close.append(self.ltp[-1])
self.ltp = []
# Function to set ltp value
def setLtp(self,ltp):
# Function to get candles dataframe
def getOhlc(self):
data = pd.DataFrame(
data={
'timeStamp' : self.timeStamp,
'Open' : self.open,
'High' : self.high,
'Low' : self.low,
'Close' : self.close,
},
columns=
['timeStamp','Open','High','Low','Close']
)
data = data.set_index('timeStamp')
return data
# class to store all pocket data
class database:
def __init__(self,tokens,startTime,delay):
self.pockets = {}
self.startTime = startTime
self.delay = delay
self.execution = startTime + delay
for token in tokens:
self.pockets[token] = pocket(token)
# Function to get pocket object by
token number
def getPocket(self,token):
return self.pockets[token]
# Setting ltp value based on token
def setVal(self,token,ltp):
self.getPocket(token).setLtp(ltp)
# Function to check of candle time is

executed
__________________________________________________
def checkCandle(self):
if(datetime.datetime.now()>self.executio
n):
self.execution += self.delay
for token in self.pockets:
self.pockets[token].ohlc()
# Set the new candle to be
available
self.pockets[token].newData = 1
# Function to get candles dataframe of
token
def getOhlc(self,token):
return
self.getPocket(token).getOhlc()
# Function to print dataframe of token
pocket
# if new candle is formed
def newCandle(self,token):
if(self.getPocket(token).newData):
self.getPocket(token).newData = 0
print('\n',token)
print(self.getOhlc(token))
# zerodha credentials
api_key = "your api_key"
api_secret = "your api_secret"
__________________________________________________
username = "your username"

password = "your password"
pin = "your pin"
# function to wait for elements on page load
for selenium
def getCssElement( driver , cssSelector ):
return WebDriverWait( driver, 100
).until( EC.presence_of_element_located( (
By.CSS_SELECTOR, cssSelector ) ) )
#function to login to zerodha using selenium
def autologin():
service =
service.start()
driver =
passwordField = getCssElement( driver
, "input[placeholder=Password]" )
passwordField.send_keys( password )
userNameField = getCssElement( driver
, "input[placeholder='User ID']" )
userNameField.send_keys( username )
loginButton.click()
WebDriverWait(driver,
100).until(EC.presence_of_element_located((By.CLAS
S_NAME, 'twofa- value')))
pinField =
driver.find_element_by_class_name('twofa-
value').find_element_by_xpath(".//input[1]")
pinField.send_keys( pin )
loginButton.click()
while True:
try:
request_token=furl(driver.current_url).args[
'request_token'].strip()
break
except:
time.sleep(1)
data =
kite.generate_session(request_token,
api_secret=api_secret)
with open('access_token.txt', 'w') as
file:
__________________________________________________
file.write(data["access_token"])
driver.quit()
autologin()
# retrieving access token from saved file
access_token_zerodha =
open("access_token.txt",'r').read()
# Tokens to subscribe
TOKENS = [738561, 5633]
# #creating kite connect object
# # setting access token ti kite connect
object
kite.set_access_token(access_token_zerodha)
# time at which code starts
STARTTIME = datetime.datetime.now()
#time at which code ends
ENDTIME =
datetime.datetime.now().replace(hour=15,minute=30,
second=0)
#duration of a candle
DELAY =
datetime.timedelta(hours=0,minutes=1,seconds=0)
# Initiating Database
DATABASE = database(TOKENS,STARTTIME,DELAY)
__________________________________________________
#waits till start time

while datetime.datetime.now()<STARTTIME:
pass
#kite ticker object to receive data from

zerodha
kws = KiteTicker(api_key,
access_token_zerodha)
#function to run when data is coming from
zerodha
global DATABASE
#creating new candles based on
execution time
#recording current data to database
for all tickers
DATAb BASE.checkCandle()
for x in ticks:
DATABASE.setVal(x['instrument_token'],x['last_pr
ice'])
DATABASE.newCandle(x['instrument_token'])
# Strategy to buy after 3 continuous
increasing
# highs and sell after 3 continuous
decreasing lows
__________________________________________________
if
len(DATABASE.getOhlc(x['instrument_token']))>3:
tempDb =
DATABASE.getOhlc(x['instrument_token'])
if(tempDb.iloc[-1]
['High']>tempDb.iloc[-2]['High'] and
tempDb.iloc[-2]['High']>tempDb.iloc[-3]
['High']):
order_id=
kite.place_order(tradingsymbol=x['instrument_token
'],
exchange=kite.EXCHANGE_NSE,
transaction_type=kite.TRANSACTION_TYPE_BUY,
quantity=1,
order_type=kite.ORDER_TYPE_MARKET,
product=kite.PRODUCT_NRML)
print(oid)
elif(tempDb.iloc[-1]['Low']
<tempDb.iloc[-2]['Low'] and
tempDb.iloc[-2]['Low']>tempDb.iloc[-3]['Low']):
order_id =
kite.place_order(tradingsymbol=x['instrument_token
'],exchange=kite.EXCHANGE_NSE,
transaction_type=kite.TRANSACTION_TYPE_
SELL,quantity=1,
order_type=kite.ORDER_TYPE_MARKET,produ
ct=kite.PRODUCT_NRML)
print(oid)
#if current time is greater than
ENDTIME the stop the code
if(datetime.datetime.now()>ENDTIME):
print("Market is closed now...")
ws.stop()
#function to run when connection is
established to zerodha
# Callback on successful connect.
ws.subscribe(TOKENS)
#funcion to run on connection close
# On connection close stop the main
loop
# Reconnection will not happen after
executing `ws.stop()`
print(code)
print(reason)
ws.stop()
#Assign the callbacks.
__________________________________________________
# Infinite loop on the main thread. Nothing

after this will run.
# You have to use the pre-defined callbacks
to manage subscriptions.
kws.connect()
__________________________________________________
Appendix
print: python function used to output data
function:A function is a block of code which only runs when it is called.
You can pass data known as a parameter as a function. A function can
return data as a result.
api: An application program interface (API) is a set of routines, protocols,
and tools for building software applications.
import: python keyword used to get external function into current code
object: an instance of a class
class: A Class is like an object constructor, or a "blueprint" for creating
objects.
type: python function used to find the data type of a variable
requests: python library to create get, post, delete etc. requests.
kiteconnect: Zerodha’s python api for retrieving data, placing orders etc.
input: python function to take input in python
pandas: python library to manage data
def : python keyword to define functions
stock : underlying instrument available for sale or purchase over exchange
zerodha : Indian financial service company, that offers retail and
institutional broking, currencies and commodities trading, mutual funds,
and bonds.
time : python library to handle time
ticks : dictionary object containing data for a single stock for a single
transaction live data
ltp : last traded price of a stock
pip : python library installation and management software
dictionary: python data type which stores data as key value pair
list : python data type to store data at continuous indices
dataframe: data type of pandas library in python to store data as a table of
indices and headers
kiteticker : kite connect object for live data
datetime : python library to handle date and time
numpy : python library to handle complex arithmetic operations as a group
(array, vector etc.)
series : pandas data type which represents a row or a column which
combine to become a data frame
selenium : python library for browser automation
webdriver : selenium object to handle various browsers like chrome,
Firefox etc
socket : A network socket is a software structure within a network node of
a computer network that serves as an endpoint for sending and receiving
data across the network.
trading : Trade in stock markets means the transfer (in exchange for money)
of a stock or security from a seller to a buyer.
library : a collection of predefined function, classes, and variable to be used
in other codes
exchange : A stock exchange is a facility where stockbrokers and traders
can buy and sell securities, such as shares of stock and bonds and other
financial instruments.
Jupyter-notebook: The Jupyter Notebook is an open-source web application
that allows you to create and share documents that contain live code,
equations, visualizations and narrative text.
stoploss : A stop-loss order is an order placed with a broker to buy or sell
once the stock reaches a certain price. A stop-loss is designed to limit an
investor's loss on security position.
float : python data type representing numbers containing decimal
append : function to insert elements in python list
set: python data type which stores only unique elements
streaming : Streaming data is data that is continuously generated by
different sources. Such data should be processed incrementally using
Stream Processing technique without having access to all of the data
keyword : Keywords are the reserved words in Python. We cannot use a
keyword as a variable name, function name or any other identifier.
break : python keyword to exit a loop
candle : A candlestick chart is a style of financial chart used to describe
price movements of a security, derivative, or currency.
tuple : A tuple is a collection of objects which are ordered and immutable.
Tuples are sequences, just like lists. The differences between tuples and lists
are, the tuples cannot be changed unlike lists and tuples use parentheses,
whereas lists use square brackets.
indicators: Technical Indicator is essentially a mathematical representation
based on data sets such as price (high, low, open, close, etc.) or volume of
security to forecast price trends.
split : python function to split a string based on input string
timestamp : a string representation of datetime object
lambda : python keyword to generate single line functions
matplotlib : python library to generate graphs
seaborn : python library to create graphs based on matplotlib
range : python function to create generators for numbers
ohlc : shart for for -> open high low and close
arrays : python numpy data type to represent mathematical arrays
try-except: python keyword to catch and handle errors
sleep : python function to delay execution of further lines
pprint : python library to print data types in readable form
comments : python statements which are not actually executed but are
written for human readability of code
len : python function to determine the length of a string
strip : python function to remove white spaces before and after a string
pyplot : matplotlib.pyplot is a collection of functions that make matplotlib
work like MATLAB. Each pyplot function makes some change to a figure:
e.g., creates a figure, creates a plotting area in a figure, plots some lines in a
plotting area, decorates the plot with labels, etc.
os : This module provides a portable way of using operating system
dependent functionality.
github : GitHub is a Git repository hosting service, but it adds many of its
own features. While Git is a command line tool, GitHub provides a Web-
based graphical interface. It also provides access control and several
collaboration features, such as a wikis and basic task management tools for
every project.
csv : comma separated values (csv) is a file type to store data like in excel
sql : SQL is a domain-specific language used in programming and
designed for managing data held in a relational database management
system, or for stream processing in a relational data stream management
system.
io : The io module provides Python’s main facilities for dealing with
various types of I/O.
str : python representation of string (set of characters)
immutable : unchanging over time or unable to be changed.
json : JavaScript Object Notation is an open standard file format, and data
interchange format, that uses human-readable text to store and transmit data
objects consisting of attribute–value pairs and array data types.
logging : python library used to log outputs
squareoff : Squaring off is a trading style used by investors/traders mostly
in day trading, in which a trader buys or sells a particular quantity of an
asset (mostly stocks) and later in the day reverses the transaction, in the
hope of earning a profit (price difference net of broker charges and tax
asynchronous: Asynchronous programming is a means of parallel
programming in which a unit of work runs separately from the main
application thread and notifies the calling thread of its completion, failure
or progress.
timedelta : python datetime object to define time duration
global : keyword to declare variables to be used in and out of every
variable

Tewani, Puneet - Step by Step Automation Using Zerodha API - Python Version (2020)

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tewani, Puneet - Step by Step Automation Using Zerodha API - Python Version (2020)

Uploaded by

Copyright:

Available Formats

ACKNOWLEDGEMENTS

I would like to thank all my mentors, especially Mr. Vihan Singh.

This will install PIP.

pip install Jupyter notebook

This will install your Jupyter notebook.

Integers are whole number, without decimal points

Numbers with decimal points

Example of a print statement:

Operator Name Example

Assignment operators in python are used to assign values to variables.

Operator Example Same As

&= x &= 3 x=x&3

>>= x >>= 3 x = x >> 3

<<= x <<= 3 x = x << 3

Comparison operators in python are used to compare two values:

Operator Name Example

> Greater than x>y

< Less than x<y

>= Greater than or equal to x >= y

<= Less than or equal to x <= y

Operator Description Example

or Returns True if one of the statements is x < 5 or x < 4

Operator Description Example

is Returns True if both variables are the same x is y

is not Returns True if both variables are not the x is not y

Data can also be removed by list:

len((1, 2, 3)) 3 Length

(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) Concatenation

('Hi!',) * 4 ('Hi!', 'Hi!', 'Hi!', 'Hi!') Repetition

3 in (1, 2, 3) True Membership

for x in (1, 2, 3): 123 Iteration

There are two types of functions in Python:

2. User defined functions: The functions which we create in our

User Defined Function Template-

3. Data Encapsulation – It is the process of wrapping up the data and its

Accessing array Elements: Indexing

Pandas Dataframe Indexing-

Data visualisation forms an integral part of any strategy as we formulate

B) Categorical Relationship (Categorical vs Numerical):

For Univariate analysis- sns.displot()

For Bivariate analysis- sns.jointplot()

Setting Up Environment Variables

Example to find instrument token of a particular stocks is given below

○ ws - It is the reference to the KiteTicker object

2. on_close(ws, code, reason) - It is triggered when connection

○ ws - It is the reference to the KiteTicker object

3. on_error(ws, code, reason) - This function is executed when

○ ws - It is the reference to the KiteTicker object

○ ws - It is the reference to the KiteTicker object

5. on_message(ws, payload, is_binary) - This is an optional

○ ws - It is the reference to the KiteTicker object

6. on_reconnect(ws, attempts_count) - It is another optional

○ ws - It is the reference to the KiteTicker object

7. on_noreconnect(ws) - Reverse of on_reconnect function, i.e.

○ ws - It is the reference to the KiteTicker object

8. on_order_update(ws, data) - This is triggered when there is

○ ws - It is the reference to the KiteTicker object

Sample Socket Code -

def on_ticks(ws, ticks):

Trading Symbol - Retrieve using the instruments() function

Technical Indicators & Price Action

As the name suggests, we used some techniques to derive some meaningful

17.2.2 Bollinger Bands