# import yfinance as yf

import pandas as pd
# import finplot as fplt
import numpy as np
import time
import sys
import talib as ta
import datetime
import pandas_ta as pandasTa
import math
import pyotp
from SmartAPI import SmartConnect

import sys
import os
sys.path.append(os.getcwd())
# from Strategy.RUDY.equityList import SdTicker, stockList
from Strategy.HFT.AngelOneDataDownloadUDF import getIntradayData

# ──────────────────────────────────────────────────────────────────────────────
api_key = 'nRijEqvd'
username = 'A529721'
pwd = 'Ridak@0786'
pin = '4321'
token = "EBVXXHCJUHDS5IFVPG6KJADOKY"

totp = pyotp.TOTP(token).now()

smartApi = SmartConnect(api_key)
smartApi.generateSession(username, pin, totp)

# ─── 𝗦𝗘𝗡𝗗
⁣
⁢
⁡ 𝗠𝗦𝗚 𝗧𝗢 𝗔 𝗦𝗣𝗘𝗖𝗜𝗙𝗜𝗖 𝗚𝗥𝗢𝗨𝗣⁡
───────────────────────────────────────────────────────────────────────
import asyncio
from telegram import Bot

async def send_message(msg):

bot_token = "7277333734:AAHrJf-z3xTAag9hToabPgxmNQJKh3uIs50"
# chat_id = "999149701" # this is my bot ID
chat_id = "-4538072667" # Replace with the actual group chat ID

bot = Bot(token=bot_token)
await bot.send_message(chat_id=chat_id, text=msg)

def angelOneBot(msg):
loop = asyncio.new_event_loop()
asyncio.set_event_loop(loop)
loop.run_until_complete(send_message(msg))
loop.close()

SdTicker =['POLYCAB']
# Trades_Data =
pd.read_excel("/Users/nijanjyakhwo/Splash_Trade_Automation/Strategy_Excel/
StandardDeviationSpring.xlsx")
def print_red(text):
print('\033[91m' + text + '\033[0m')

# SdTicker = ["RELIANCE.NS"]

tradeData = pd.DataFrame()
# SdTicker = ['AARTIIND']

# ─── DOWNLOADING DATA FROM YFINANCE ───────────────────────────────────────────

for a in range(1000) :
try :
stockList = []
startTime = time.time()
failedTickers =[]
for i,StockName in enumerate(SdTicker):
try :
print(i)

print(StockName)
stockName = StockName

def func_stockFuturesAndATMstrike(stockName):
# ───────────── HISTORICAL DATA RANGE FOR STOCK DOWNLOAD
─────────────────────────────────────────────────────────────────
# token = 99926037
import datetime
currentTime = datetime.datetime.now()
threeDayBackDate = currentTime - datetime.timedelta(days = 50)
threeDayBackDate = threeDayBackDate.strftime("%Y-%m-%d") + "
09:15"
currentTime = currentTime.strftime("%Y-%m-%d %H:%M")

# ───────────── STOCK FUTURES NAME AND ITS TOKEN

─────────────────────────────────────────────────────────────────

stockTokenData = pd.read_excel("/Users/nijanjyakhwo/Splash-
Trade-Automation/Strategy/Broker/AngelOne/StockAndOptionsTokenExcelFile/
stockFuturesToken.xlsx")
stockNameIdx = np.where((stockTokenData["name"] == stockName)
& (stockTokenData['symbol'].str.contains('OCT', case=True, na=False)))[0][0]
stockToken = int(stockTokenData.at[stockNameIdx, "token"])

# ─────────────── DOWNLOAD STOCK DATA

───────────────────────────────────────────────────────────────
data = getIntradayData(smartApi, "NFO", stockToken,
"FIVE_MINUTE", historicalDays=7)
print(stockToken)
 lastIdx = data.index[-1]
ltp = data.at[lastIdx, "Close"]

# ─────────────── FINDING ATM STRIKE PRICE

───────────────────────────────────────────────────────────────
# ─────────────── 1. Current Month Options Data
───────────────────────────────────────────────────────────────
currentMonthShortForm =
datetime.datetime.now().strftime("%b").upper()
stockOptionsTokenData =
pd.read_excel("/Users/nijanjyakhwo/Splash-Trade-Automation/Strategy/Broker/
AngelOne/StockAndOptionsTokenExcelFile/stockOptionsToken.xlsx")
currentMonthlyOPtions =
np.where((stockOptionsTokenData["name"] == stockName) &
(stockOptionsTokenData['symbol'].str.contains('OCT', case=True, na=False)))

currentMonthlyOPtionsData =
stockOptionsTokenData.loc[currentMonthlyOPtions]
currentMonthlyOPtionsData =
currentMonthlyOPtionsData.reset_index(drop = True)
currentMonthlyOPtionsData =
currentMonthlyOPtionsData.reset_index(drop = True)

# ─────────────── 2. Current Month ATM STRIKE PRICE

───────────────────────────────────────────────────────────────
currentMonthlyOPtionsData["diffBtwnStrikeAndLTP"] =
abs(currentMonthlyOPtionsData["strike"] - ltp)
minDiffBetwnStrikeAndLTP =
currentMonthlyOPtionsData["diffBtwnStrikeAndLTP"].min()
stockATMstrikeIdx =
np.where(currentMonthlyOPtionsData["diffBtwnStrikeAndLTP"] ==
minDiffBetwnStrikeAndLTP)[0][0]
stockATMstrike =
currentMonthlyOPtionsData.at[stockATMstrikeIdx, "strike"]
# currentMonthlyOPtionsStrike =
currentMonthlyOPtionsData["strike"].values

# ─────────────── 3. STOCK OPTIONS ATM SYMBOL AND TOKEN

───────────────────────────────────────────────────────────────
stockATMsymbol =
currentMonthlyOPtionsData.at[stockATMstrikeIdx, "symbol"]
stockATMcallSymbol = stockATMsymbol[:-2] + "CE"
stockATMputSymbol = stockATMsymbol[:-2] + "PE"

stockATMcallIdx = np.where(currentMonthlyOPtionsData["symbol"]
== stockATMcallSymbol)[0][0]
stockATMputIdx = np.where(currentMonthlyOPtionsData["symbol"]
== stockATMputSymbol)[0][0]

stockATMcallToken =
int(currentMonthlyOPtionsData.at[stockATMcallIdx, "token"])
stockATMputToken =
int(currentMonthlyOPtionsData.at[stockATMputIdx, "token"])

print(f"stockATMcallSymbol = {stockATMcallSymbol}")
print(f"stockATMcallIdx = {stockATMcallIdx}")
print(f"stockATMcallToken = {stockATMcallToken}")

print(f"stockATMputSymbol = {stockATMputSymbol}")
print(f"stockATMputIdx = {stockATMputIdx}")
print(f"stockATMputToken = {stockATMputToken}")

# ────────────── ATMstrikeData
────────────────────────────────────────────────────────────────
# ───────────── HISTORICAL DATA RANGE FOR OPTIONS DATA DOWNLOAD
─────────────────────────────────────────────────────────────────
token = 99926037
import datetime
currentTime = datetime.datetime.now()
threeDayBackDate = currentTime - datetime.timedelta(days = 20)
threeDayBackDate = threeDayBackDate.strftime("%Y-%m-%d") + "
09:15"
currentTime = currentTime.strftime("%Y-%m-%d %H:%M")

callATMData = getIntradayData(smartApi, "NFO",

stockATMcallToken, "FIVE_MINUTE", historicalDays=7)
# time.sleep(1)
putATMData = getIntradayData(smartApi, "NFO", stockATMputToken,
"FIVE_MINUTE", historicalDays=7)
# print(callATMData)

return callATMData, putATMData, stockATMcallSymbol,

stockATMputSymbol

# ───────────── ⁡
CALL AND PUT DATA⁡
⁢
⁣
─────────────────────────────────────────────────────────────────
# stockName = "CIPLA"
callAndPutData = func_stockFuturesAndATMstrike(stockName)
callATMData = callAndPutData[0]
putATMData = callAndPutData[1]
stockATMcallSymbol = callAndPutData[2]
stockATMputSymbol = callAndPutData[3]

# ────────────────── ⁡
STRATEGY CONDITION⁡
⁢
⁣
────────────────────────────────────────────────────────────
def func_StrategyCondition(data):
 # ──────────── 1. Volume Condition
──────────────────────────────────────────────────────────
# fplt.volume_ocv(data[['Datetime','Open','Close','Volume']],
ax=axo)

data['EMA20vol'] = data["Volume"].ewm(span=20,
adjust=False).mean()
data["volCondition"] = data["Volume"] >= data['EMA20vol'] * 1.5
# fplt.plot(data['Datetime'], data["EMA20vol"], color = "black
", width=2, ax=axo, legend='volume ma')

# ──────────── 2. RSI Condition

──────────────────────────────────────────────────────────
# ─────────── ⁡
RSI14⁡
⁢
⁣
───────────────────────────────────────────────────────────────────
def func_RMA(series, period):
return series.ewm(alpha=1/period, adjust=False).mean()

def func_RSI(data, column, period):

delta = data[column].diff(1)

up = delta.where(delta > 0, 0)
down = -delta.where(delta < 0, 0)

avg_gain = func_RMA(up, period)

avg_loss = func_RMA(down, period)

rs = avg_gain / avg_loss
rsi = np.where(avg_loss == 0, 100, np.where(avg_gain == 0,
0, 100 - (100 / (1 + rs))))

data[f'RSI{14}'] = rsi
data[f'prevRSI{14}'] = data[f'RSI{14}'].shift(1)
return data
func_RSI(data, column='Close', period=14)
data["40"] = 40
data["60"] = 60
# fplt.plot(data['Datetime'], data['RSI14'], color = "black ",
width=2, legend='RSI14', ax = ax1)
# # fplt.plot(data['Datetime'], data["40"], color = "black ",
width=2, legend='RSI14', ax = ax1)
# fplt.plot(data['Datetime'], data["60"], color = "black ",
width=2, legend='RSI14', ax = ax1)

data["RSIcondition"] = data["RSI14"] >= 60

# ──────────── 3. VWAP Condition

──────────────────────────────────────────────────────────
# VWAP = Cumulative Typical Price x Volume/Cumulative Volume
# Where Typical Price = High price + Low price + Closing
Price/3

# ────── 1. Computation of Average OF H,L,C,V

────────────────────────────────────────────────────────────────────────
 data["cumulativeTypicalPriceMultiplyByVolume"] =
round(((data["High"] + data["Low"] + data["Close"]) / 3) * data["Volume"], 2)
# print(data["cumulativeTypicalPriceMultiplyByVolume"])

# ─── ⁡
COMPUTATION OF PIVOT POINT⁡
⁢
────────────────────────────────────────
data["year"] = data["Datetime"].dt.year
data["month"] = data["Datetime"].dt.month
data["day"] = data["Datetime"].dt.day
data["hour"] = data["Datetime"].dt.hour
data["minute"] = data["Datetime"].dt.minute

# ────────────── ⁡
SESSION SEPARATION⁡
⁢
⁣
────────────────────────────────────────────────────────────────
data["newDay"] = None
# oneHourCondition =((data["hour"] == 9) & (data["minute"] ==
15)) | ((data["hour"] == 10) & (data["minute"] == 15)) | ((data["hour"] == 11) &
(data["minute"] == 15)) | ((data["hour"] == 12) & (data["minute"] == 15)) |
((data["hour"] == 13) & (data["minute"] == 15)) | ((data["hour"] == 14) &
(data["minute"] == 15))
# twoHourCondition =((data["hour"] == 9) & (data["minute"] ==
15)) | ((data["hour"] == 11) & (data["minute"] == 15)) | ((data["hour"] == 13) &
(data["minute"] == 15))
# threeHourCondition =((data["hour"] == 9) & (data["minute"] ==
15)) | ((data["hour"] == 12) & (data["minute"] == 15)) | ((data["hour"] == 15) &
(data["minute"] == 15))
wholeDayCondition =((data["hour"] == 9) & (data["minute"] ==
15))

daySeparateIdxArray = np.where(wholeDayCondition)[0]
data.loc[daySeparateIdxArray, "newDay"] = "newDay"
# Text_List_Fplt(Dataframe = data, Index =
daySeparateIdxArray , Column1 = "Datetime", Column2 = "Low", Text = "15" ,
font_family= "Roboto", font_size =9, font_style = "Bold", font_color = "brown")

# ───── 2. VWAP Computation

─────────────────────────────────────────────────────────────────────────
data["VWAP"] = None
data["vwapCondition"] = False
marketOpenTimeIdxArray = daySeparateIdxArray
for idx in marketOpenTimeIdxArray:
# ────── 2(A). Market Opening Index and Its Day
────────────────────────────────────────────────────────────────
currentMarketOpenTimeIdx = idx
marketOpeningBarDay = data.at[currentMarketOpenTimeIdx,
"day"]

# ────── 2(B). Applying VWAP Formula

────────────────────────────────────────────────────────────────
for i in range(currentMarketOpenTimeIdx,
currentMarketOpenTimeIdx+ 75) :
if i in data.index :
currentBarIdx = i
currentBarDay = data.at[currentBarIdx, "day"]

if marketOpeningBarDay == currentBarDay :
cumulativeVolTillCurrentBarOfDay =
data.loc[currentMarketOpenTimeIdx : currentBarIdx, "Volume"].sum()
if cumulativeVolTillCurrentBarOfDay >= 1:
cumulativePriceMultiplyVOl =
data.loc[currentMarketOpenTimeIdx : currentBarIdx,
"cumulativeTypicalPriceMultiplyByVolume"].sum()
VWAP = round(cumulativePriceMultiplyVOl/
cumulativeVolTillCurrentBarOfDay, 2)
data.at[currentBarIdx, "VWAP"] = VWAP
# print(i)
data['VWAP'] = pd.to_numeric(data['VWAP'], errors='coerce')
valid_data = data["Close"].notna() & data["VWAP"].notna()
data.loc[valid_data, "vwapCondition"] = data.loc[valid_data,
"Close"] > data.loc[valid_data, "VWAP"]
# ────── 3. Plotting VWAP
────────────────────────────────────────────────────────────────────────
# fplt.plot(data['Datetime'][:], data['VWAP'][10:], color =
"blue", width=2, legend='VWAP' )

conditionFulfilledIdxArray = np.where((data["vwapCondition"] ==
True) & (data["RSIcondition"] == True) & (data["volCondition"] == True))[0]
# Text_List_Fplt(Dataframe = data, Index =
conditionFulfilledIdxArray , Column1 = "Datetime", Column2 = "Low", Text = "R" ,
font_family= "Roboto", font_size =9, font_style = "Bold", font_color = "brown")

conditionFulfilled = False
conditionFulfilledTime = False
# data['timestamp_utc'] =
data['Datetime'].dt.tz_localize('UTC')

# # Convert to desired timezone (UTC+5:30 or 'Asia/Kolkata')

# data['Datetime'] =
data['timestamp_utc'].dt.tz_convert('Asia/Kolkata')

if (len(data) >= 1) and (np.size(conditionFulfilledIdxArray) >=

1):
lastIdx = data.index[-1]
# print("A")
print(conditionFulfilledIdxArray[-1])
# print(lastIdx)
if conditionFulfilledIdxArray[-1] == lastIdx:
conditionFulfilled = True
conditionFulfilledTime = data.at[lastIdx, "Datetime"]

return conditionFulfilled,conditionFulfilledTime

# data = callATMData
# ─── ⁢
⁡LOTTING CANDLESTICK CHART AND CREATING REQUIRED NUMBER OF
P
⁣
ROWS⁡────────────────────────────────────────────────────────────────
# ─── ⁡
BACKGROUND COLOR AND CREATION OF ROW⁡
⁢
────────────────────────────────────────────────────────────────────────
# ax,ax1, ax2 = fplt.create_plot('Price & RSI', rows=3)
# w = fplt.foreground = '#eef'
# fplt.cross_hair_color = "#000"

# b = fplt.background = fplt.odd_plot_background = '#e9edf7'

# p = fplt.candlestick_ochl(callATMData[["Datetime", "Open",
"Close", "High", "Low"]])
# p.colors.update(dict(bull_body='white', bull_shadow='#787b86',
bull_frame='#787b86',
# bear_body='#787b86', bear_shadow='#787b86',
bear_frame='#787b86'))

# axo = ax.overlay()

callATMcondition = func_StrategyCondition(callATMData)
callATMconditionFulfilled = callATMcondition[0]
callATMconditionFulfilledTime = callATMcondition[1]

putATMcondition = func_StrategyCondition(putATMData[:-6])
putATMconditionFulfilled = putATMcondition[0]
putATMconditionFulfilledTime = putATMcondition[1]

print_red("THIS IS THE DATA")

print(putATMconditionFulfilledTime)

# optionsList = []
if callATMconditionFulfilled == True:
ab = [stockATMcallSymbol, callATMconditionFulfilledTime]
# optionsList.append(stockATMcallSymbol)
stockList.append(ab)
print_red("YESssssssssssss")

if putATMconditionFulfilled == True:

# optionsList.append(stockATMputSymbol)#
Text_List_Fplt(Dataframe = data, Index = currentDayConditionIdxArray , Column1 =
"Datetime", Column2 = "Low", Text = "C" , font_family= "Roboto", font_size =9,
font_style = "Bold", font_color = "green")
ab = [stockATMputSymbol, putATMconditionFulfilledTime]
stockList.append(stockATMputSymbol)
print_red("YESssssssssssss")

time.sleep(2)

# list.append(True)

now = arrow.utcnow()
current_time = now.to('local').format('HH:mm:ss')
####print(current_time)
#
 except Exception as e:
failedTickers.append(stockName) # Append the ticker to the

if len(stockList) >= 1:
angelOneBot(f"""ANGEL ONE OPTIONSLIST,\n TIMEFRAME = 5 Minutes \n
Options List = {stockList}""")
print(stockList)

time.sleep(300)

except Exception as e:
print("ERROR")
print(e)

end_time = time.time()
elapsed_time = end_time - startTime
print("Elapsed time: {:.2f} seconds".format(elapsed_time))
import arrow
now = arrow.utcnow()
current_time = now.to('local').format('HH:mm:ss')
print(current_time)