## How to automate the Simple Moving Average Strategy using Alice Blue

The calculation of the Simple Moving Average is fairly simple. It has two properties – `Length`, `Source`.

Like – `SMA(5, Close)` takes the closing prices of the last `5 points` and divides it by `5`.

It is regardless of the timeframe. If you take the points on an hourly timeframe i.e. you feed the data one closing point at the end of each hour. `SMA(5, Close)` will take the closing prices of the last `5 points` and divides it by `5`.

Here is `SMA(5,Close)` and `SMA(10,Close)` plotted into INFY.

Here is the Tradingview Chart published – Infy Alice Blue Crossover Strategy Reference for NSE:INFY by Amit_Ghosh ## Strategy

As per the Moving Average Crossover Strategy’s theory, when SMA of smaller length crosses the SMA of bigger length, it will generate a buy signal. And, vice-versa.

Also, the source has to be (here, it is assumed `close`) the same.

Apart from normal Python local IDEs, You can also use Google Collab which is a sort of online Jupyter Notebooks. Let’s install the Python SDK for Alice Blue API written by krishnavelu.

Type `pip install alice-blue` and press enter.

## The Code Snippet

Here goes the code snippet of Simple Moving Average Strategy written by krishnavelu

```				```
import logging
import datetime
import statistics
from time import sleep
from alice_blue import *

# Config
api_secret = 'api_secret'
twoFA = 'a'
EMA_CROSS_SCRIP = 'INFY'
logging.basicConfig(level=logging.DEBUG)        # Optional for getting debug messages.
# Config

ltp = 0
socket_opened = False
alice = None
def event_handler_quote_update(message):
global ltp
ltp = message['ltp']

def open_callback():
global socket_opened
socket_opened = True

global alice
instrument = ins_scrip,
quantity = 1,
order_type = OrderType.Market,
price = 0.0,
trigger_price = None,
stop_loss = None,
square_off = None,
trailing_sl = None,
is_amo = False)

def sell_signal(ins_scrip):
global alice
alice.place_order(transaction_type = TransactionType.Sell,
instrument = ins_scrip,
quantity = 1,
order_type = OrderType.Market,
price = 0.0,
trigger_price = None,
stop_loss = None,
square_off = None,
trailing_sl = None,
is_amo = False)

def main():
global socket_opened
global alice
global twoFA
global api_secret
global EMA_CROSS_SCRIP
minute_close = []

print(alice.get_balance()) # get balance / margin limits
print(alice.get_profile()) # get profile
print(alice.get_daywise_positions()) # get daywise positions
print(alice.get_netwise_positions()) # get netwise positions
print(alice.get_holding_positions()) # get holding positions

ins_scrip = alice.get_instrument_by_symbol('NSE', EMA_CROSS_SCRIP)

socket_opened = False
alice.start_websocket(subscribe_callback=event_handler_quote_update,
socket_open_callback=open_callback,
run_in_background=True)
while(socket_opened==False):    # wait till socket open & then subscribe
pass
alice.subscribe(ins_scrip, LiveFeedType.COMPACT)

current_signal = ''
while True:
if(datetime.datetime.now().second == 0):
minute_close.append(ltp)
if(len(minute_close) > 20):
sma_5 = statistics.mean(minute_close[-5:])
sma_20 = statistics.mean(minute_close[-20:])
if(sma_5 > sma_20):
if(current_signal != 'sell'):
if(sma_5 < sma_20):
sell_signal(ins_scrip)
current_signal = 'sell'
sleep(1)
sleep(0.2)  # sleep for 200ms

if(__name__ == '__main__'):
main()
```
```

## Explanation of Code

Let’s explain this following code block of the strategy –

```				```
while True:
if(datetime.datetime.now().second == 0):
minute_close.append(ltp)
if(len(minute_close) > 20):
sma_5 = statistics.mean(minute_close[-5:])
sma_20 = statistics.mean(minute_close[-20:])
if(sma_5 > sma_20):
elif(sma_5 < sma_20):
sell_signal(ins_scrip)
sleep(1)
sleep(0.2)
```
```
• It is seeking for LTP of the stock at the time when seconds are 00 like 19:16:00
• It appends the LTP to an array `minute_close` array.
• Now unless there is 20 points in that array we can not get SMA(20, Close) right? That’s why the if function is there.

Why Sleep functions? It is because we will get tons of LTP in one second alone. Don’t forget microseconds. It will be flooded. Exchanges do not have a concept of timeframe. They just throw the LTPs and we create the chart based on it with time frames.

So, the first moment we get a price, it tells to sleep for one second. If that second is over, it will hence wait for whole 59 seconds more before seconds became 00.

So, This is how We are creating mean of Candlesticks in Different Timeframes to get SMA.

`buy_signal` and `sell_signal` are pretty small functions that execute orders. That’s all.

```				```
# Config