Algo trading functions

import datetime as dt
from datetime import datetime, timedelta
import pandas as pd
import json
import sys
import hmac
import hashlib
import time
from typing import List
from websocket import WebSocketApp
import logging
from zoneinfo import ZoneInfo
from delta_rest_client import DeltaRestClient ,OrderType
import requests
import numpy as np
np.NaN = np.nan
import pandas_ta
import threading

-----------------------------------------------------------------------------

API Keys and DeltaRestClient setup

API_KEY = ‘’
API_SECRET = ‘’
delta_client = DeltaRestClient(
base_url=‘https://api.india.delta.exchange’,
api_key=API_KEY,
api_secret=API_SECRET
)
def sell_bracket_order_limit(symbol ,lot , limit_price , sltriggerprice ,sllimitprice , tgtriggerprice,tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: lot,
“side”: “sell”,
“order_type”: “limit_order”,

“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,

“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”,prams,auth=True).json()
return response

def buy_bracket_order_limit(symbol ,lot , limit_price , sltriggerprice ,sllimitprice , tgtriggerprice,tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: lot,
“side”: “buy”,
“order_type”: “limit_order”,

“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,

“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”,prams,auth=True).json()
return response[‘id’]

def modify_order_qty(symbol,orderno,qty):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘size’: qty,
#‘limit_price’: str(0.2)
}
response = delta_client.request(“PUT”, “/v2/orders”, order,auth=True)
return response[‘state’]
def modify_order_price(symbol,orderno,price):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘limit_price’: str(price)
}
response = delta_client.request(“PUT”, “/v2/orders”, order,auth=True)
return response[‘state’]

def cancel_order(symbol,orderno):
pi = delta_client.get_product(symbol)[‘id’]
orderRes=delta_client.cancel_order(product_id=pi, order_id=orderno)
return orderRes[‘state’]
def sell_limit_order(symbol ,lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘sell’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def buy_limit_order(symbol ,lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘buy’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def sell_market_order(symbol ,lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘sell’, order_type=OrderType.MARKET)
return orderRes[‘id’]
def buy_market_order(symbol ,lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘buy’, order_type=OrderType.MARKET)
return orderRes[‘id’]
def sell_sl_order(symbol ,lot, triggerprice,price ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘sell’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def buy_sl_order(symbol ,lot, triggerprice,price ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘buy’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def sell_sl_market_order(symbol ,lot, triggerprice ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘sell’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]
def buy_sl_market_order(symbol ,lot, triggerprice ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘buy’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]

1 Like

(post deleted by author)

1 Like

API Keys and DeltaRestClient setup

API_KEY = ‘’
API_SECRET = ‘’
delta_client = DeltaRestClient(
base_url=‘https://api.india.delta.exchange’,
api_key=API_KEY,
api_secret=API_SECRET
)

def sell_bracket_order_limit(symbol, lot, limit_price, sltriggerprice, sllimitprice, tgtriggerprice, tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: lot,
“side”: “sell”,
“order_type”: “limit_order”,
“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,
“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”, prams, auth=True).json()
return response

def buy_bracket_order_limit(symbol, lot, limit_price, sltriggerprice, sllimitprice, tgtriggerprice, tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: lot,
“side”: “buy”,
“order_type”: “limit_order”,
“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,
“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”, prams, auth=True).json()
return response[‘id’]

def modify_order_qty(symbol, orderno, qty):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘size’: qty,
}
response = delta_client.request(“PUT”, “/v2/orders”, order, auth=True)
return response[‘state’]

def modify_order_price(symbol, orderno, price):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘limit_price’: str(price)
}
response = delta_client.request(“PUT”, “/v2/orders”, order, auth=True)
return response[‘state’]

def cancel_order(symbol, orderno):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.cancel_order(product_id=pi, order_id=orderno)
return orderRes[‘state’]

def sell_limit_order(symbol, lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order(product_id=pi, size=lot, side=‘sell’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]

def buy_limit_order(symbol, lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order(product_id=pi, size=lot, side=‘buy’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]

def sell_market_order(symbol, lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order(product_id=pi, size=lot, side=‘sell’, order_type=OrderType.MARKET)
return orderRes[‘id’]

def buy_market_order(symbol, lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order(product_id=pi, size=lot, side=‘buy’, order_type=OrderType.MARKET)
return orderRes[‘id’]

def sell_sl_order(symbol, lot, triggerprice, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_stop_order(product_id=pi, size=lot, side=‘sell’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]

def buy_sl_order(symbol, lot, triggerprice, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_stop_order(product_id=pi, size=lot, side=‘buy’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]

def sell_sl_market_order(symbol, lot, triggerprice):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_stop_order(product_id=pi, size=lot, side=‘sell’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]

def buy_sl_market_order(symbol, lot, triggerprice):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_stop_order(product_id=pi, size=lot, side=‘buy’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]

apikey = ‘’
apiSecret = ‘’

from delta_rest_client import DeltaRestClient ,OrderType

delta_client = DeltaRestClient(
base_url=‘hxxps://api.india.delta.exchange’,
api_key=apikey,
api_secret=apiSecret
)

def sell_bracket_order_limit(symbol ,lot , limit_price , sltriggerprice ,sllimitprice , tgtriggerprice,tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: 1,
“side”: “sell”,
“order_type”: “limit_order”,

“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,

“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”,prams,auth=True).json()
return response[‘id’]

def buy_bracket_order_limit(symbol ,lot , limit_price , sltriggerprice ,sllimitprice , tgtriggerprice,tgtlimitprice):
pi = delta_client.get_product(symbol)[‘id’]
prams = {
“product_id”: pi,
“product_symbol”: symbol,
“limit_price”: limit_price,
“size”: 1,
“side”: “buy”,
“order_type”: “limit_order”,

“stop_trigger_method”: “last_traded_price”,
“bracket_stop_loss_limit_price”: sllimitprice,
“bracket_stop_loss_price”: sltriggerprice,

“bracket_take_profit_limit_price”: tgtlimitprice,
“bracket_take_profit_price”: tgtriggerprice,
“time_in_force”: “gtc”
}
response = delta_client.request(“POST”, “/v2/orders”,prams,auth=True).json()
return response[‘id’]

def modify_order_qty(symbol,orderno,qty):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘size’: qty,
#‘limit_price’: str(0.2)
}
response = delta_client.request(“PUT”, “/v2/orders”, order,auth=True)
return response[‘state’]
def modify_order_price(symbol,orderno,price):
pi = delta_client.get_product(symbol)[‘id’]
order = {
‘id’: orderno,
‘product_id’: pi,
‘limit_price’: str(price)
}
response = delta_client.request(“PUT”, “/v2/orders”, order,auth=True)
return response[‘state’]

def cancel_order(symbol,orderno):
pi = delta_client.get_product(symbol)[‘id’]
orderRes=delta_client.cancel_order(product_id=pi, order_id=orderno)
return orderRes[‘state’]
def sell_limit_order(symbol ,lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘sell’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def buy_limit_order(symbol ,lot, price):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘buy’, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def sell_market_order(symbol ,lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘sell’, order_type=OrderType.MARKET)
return orderRes[‘id’]
def buy_market_order(symbol ,lot):
pi = delta_client.get_product(symbol)[‘id’]
orderRes = delta_client.place_order( product_id= pi, size= lot, side = ‘buy’, order_type=OrderType.MARKET)
return orderRes[‘id’]
def sell_sl_order(symbol ,lot, triggerprice,price ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘sell’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def buy_sl_order(symbol ,lot, triggerprice,price ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘buy’, stop_price=triggerprice, limit_price=price, order_type=OrderType.LIMIT)
return orderRes[‘id’]
def sell_sl_market_order(symbol ,lot, triggerprice ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘sell’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]
def buy_sl_market_order(symbol ,lot, triggerprice ):
pi = delta_client.get_product(symbol)[‘id’]
orderRes =delta_client.place_stop_order(product_id=pi, size=lot, side = ‘buy’, stop_price=triggerprice, order_type=OrderType.MARKET)
return orderRes[‘id’]

They are not allowed me post full algo code , i have code for gui algo trading with supertrand , using websocket

what is your question Naren?

Hi Naren, i am using candlistic data for 1 min timeframe which is delayed by 1 min, and same is with other timeframes, i am using ema crossover, the signals are detected, can you share the timeframe, supertrend setting (10,3) or what ? if you can share the OHLC conversion from tick data , this will be helpful, are you using supertrend alone or is it in combination with other indicator, and is your trades successful ?

Hi Pankaj Ji,

i am using delta api , and using historical data to fetch the candle data for 15 mins which is delayed by 15 min, i am able to place orders, stoploss and everything, but since its delayed my entry in the market is delayed, but i want to place orders exactly when the signal is received in the live candlestick chart, i use supertrend to get the signal, but since its delayed based on historical data , i get the signal on the next candle for entry , can you suggest any fix or solution , i tried using websocket to collect all 1 min data past last 15 min of which i have the 15 min historical data and add it to the historical data and then calculate the supertrend to get the signal, but in that case, 1 min candlesticks data received via sockets, is irregular, some candles are received and some are dropped, and thus i am not able to actually build the data set to get the mean of High and Low and add it in the historical data, can you kindly help and suggest the way to do it, your suggestion or feedback will surely help. If you wish i can share the code for your kind consideration.

Best Regards,
T

hi, let me look into this but are you collecting recent trades on socket? are you seeing a drop in fills on that?

Hi @tradingwinnerindia

resolution - 15m
time label on candle - 11:45 (candle timestamp in api response)

this candles gets fromed conitnuosuly between 11:45 to 12

starting from 11:45 for next 1 minute → 11:46 → data gets aggregated

So, at 11:46 the candle is actually available onto API but the candle timstamp is 11:45
next update is at 11:47 and so on
this way finanly at 12, the candle completes and is available but candle timestamp is 11:45
Now new candle of timestamp 12 will start and first updates at 12:01

(current timestamp candle high, low, close will change every minute in the api because api serves snapshot data not the real time data)

for real time updates, web socket feed is the best way which published the latest ohlc to the user.

For websocket missing data issue, pls provide the following info, to further investigate.

  1. what channel with what exactly symbols is subscribed
  2. where are you checking irregularity from? Delta web?
  3. what kind of irregularity is detected? price difference, or any candle update which comes of delta platform but not the user subscribed channel?