omsys example

trade.py

import pyotp
import logging
from kiteext import KiteExt
import pandas as pd
from datetime import datetime as dt
from time import sleep
import json
from msexcel import Msexcel
from omspy.brokers.zerodha import Zerodha

logging.basicConfig(
     filename='INFO.log',
     level=logging.INFO, 
     format= '[%(asctime)s] %(levelname)s {%(pathname)s:%(lineno)d} - %(message)s',
     datefmt='%H:%M:%S'
    )

class Trade():
    secs = -1    
    
    def _set_mwatch(self):
        try:
            lst  = self.ms.get_lst('A2:A102', 'Marketwatch')
            self.exc = list(filter(None, lst))        
            lst = self.ms.get_lst('B2:B102', 'Marketwatch')                       
            self.inst = list(filter(None, lst)) 
            self.mwatch = [a + ':' + b for a,b in zip(self.exc,self.inst)]
            self.df = pd.DataFrame(index=self.inst, columns=['Tkn', 'Ask'])
            self.df.index.name = 'Symbol'            
        except BaseException as err:
            logging.exception("getting ticker credential {}, {}".format(err, type(err)))  
            self.ms.set_rng("HALTED: setting Marketwatch", 'G7')        

    def _get_ticker_credentials(self):
        try:
            cnfg_sht = self.ms.get_sht('Configuration')
            broker = { 'clientId': cnfg_sht.range('B1').value.strip(),
                       'password': cnfg_sht.range('B2').value.strip(),
                       '2fa'     : int(cnfg_sht.range('B3').value)   ,
                       'api_key' : cnfg_sht.range('B4').value.strip(),
                       'secret'  : cnfg_sht.range('B5').value.strip(),
                       'qr_code' : cnfg_sht.range('B6').value.strip()}
            return broker        
        except BaseException as err:
            logging.exception("getting ticker credential {}, {}".format(err, type(err)))  

    def __init__(self):
        self.ms = Msexcel()
        self.ms.set_rng("", 'G7')
        broker = self._get_ticker_credentials()
        self.kite = Zerodha( 
        api_key  = broker['api_key'],
        secret   = broker['secret'],
        PIN      = broker['2fa'],
        user_id  = broker['clientId'],
        password = broker['password'],
        totp     = broker['qr_code']
        )
        print("broker ", broker)
        print("kite ", self.kite)
        self.kite.authenticate()
        self._set_mwatch()        
    
    def set_price_to_sht(self):
        try:
            resp  = self.kite.quote(self.mwatch)        
            for k,v in resp.items():
                ask0 = json.loads(json.dumps(v['depth']['buy'][0]))
                ask = ask0['price']            
                bid0 = json.loads(json.dumps(v['depth']['sell'][0]))
                bid = bid0['price']            
                excsym = k.split(":")            
                row = [ v['instrument_token'], ask, bid]
                self.df.loc[excsym[1],['Tkn', 'Ask', 'Bid']] = row            
            self.ms.set_df(self.df, 'B1', 'Marketwatch')
        except BaseException as err:
            logging.exception("set_price_to_sht {}, {}".format(err, type(err)))  
            self.ms.set_rng("HALTED: setting price", 'G7')        

    def _sleep_till_next_sec(self):
        self.secs = dt.now().second        
        while (self.secs == dt.now().second):
            t = dt.now()    
            sleep( t.microsecond/1000000 )            

    def break_qty(self, small, big):    
        if small>big:
            self.ms.set_rng("check qty", 'G7')
            small=big
        print(small,":",big)
        rows = {}
        idx = 0
        total = small
        while total < big:
            idx += 1
            total += small            
        rows = [ idx, big-(total-small) ] if total>=big else [idx, 0]
        return rows

    def send_order(self, obj, qty=0):
        try:
            qty = int(obj['one']) if qty==0 else qty
            print("nett qty :", qty)
            obj['prc'] = obj['task'] if obj['tx'] == 'BUY' else obj['tbid']
            order = self.kite.place_order(                                
                exchange = obj['exch'],
                tradingsymbol = obj['tsym'],
                transaction_type = obj['tx'],
                quantity = qty,
                product= obj['prodt'],
                order_type= self.kite.ORDER_TYPE_LIMIT,
                price= obj['prc'],
                trigger_price = obj['prc'],
                variety = self.kite.VARIETY_REGULAR,                           
                tag=None)
            info = str(qty) + "Q #" + order
            self.ms.set_rng(info, 'U' + obj['idx'])
        except BaseException as err:
            logging.exception("send_order {}, {}".format(err, type(err))) 
            self.ms.set_rng("order error", 'U' + obj['idx'])

    def send_orders_per_sec(self, order, loops, qty=0):
        i = 0
        print("sending order(s) totalling ", loops)
        while i<loops:
            self.send_order(order, qty)
            i += 1
        self._sleep_till_next_sec()
        return None

    def send_orders(self, r, order):            
        try: 
            print(r)
            lmt_per_sec = 10
            one_lots = r[0]
            no_of_loops = int(one_lots / lmt_per_sec)
            j = 0
            while j<no_of_loops:
                print("no of loops with ", one_lots, "ones : ", no_of_loops)
                self.send_orders_per_sec(order, lmt_per_sec)
                j=+1

            if no_of_loops >= 1:
                final_iter = one_lots % lmt_per_sec            
                if final_iter > 0:
                    print("remaining orders due to rate limit :", final_iter)
                    self.send_orders_per_sec(order, final_iter)
            elif one_lots>0:
                print("ones with fractional limit :",one_lots )                 
                self.send_orders_per_sec(order, one_lots)

            if r[1] > 0:
                print("last order qty :", r[1])
                self.send_orders_per_sec(order, 1, r[1])
        except BaseException as err:
            logging.exception("send_orders {}, {}".format(err, type(err)))  

    def get_orders(self, rng='E10:T20', sht_name='Live'):
        df = None
        row_starts_at = 10
        try:
            col = ['low','high', 'bsym',
            'tsym', 'exch', 'prodt', 'qty', 'tx', 'one', 'start',
            'bask', 'task', 'tbid', 
            'lprc', 'lqty', 'ltrd']
            lst = self.ms.get_lst(rng, sht_name)
            df = pd.DataFrame(lst, columns=col)            
            # copy index and set the excel row id
            df['row_id'] = df.index + row_starts_at
            df['low'] = df['low'].fillna(0)
            df['high'] = df['high'].fillna(0)
            #df['high'].replace({"": "0"}, inplace=True)           
            df.dropna(inplace=True)
            df['start'] = df['start'].str.upper()            
            
            df_all = df.set_index('row_id')           
            print('df_all\n', df_all)
            print("")
            if(len(df_all.index)>0):
                for idx,row in df_all.iterrows():
                   row['idx'] = str(idx)
                   if (int(row['task']) < int(row['low'])) or int(row['low']==0):
                        self.ms.set_rng(row['task'], 'E' +  row['idx'])
                   if int(row['tbid']) > int(row['high']):
                        self.ms.set_rng(row['tbid'], 'F' +  row['idx'])
            
            # copy df with `Yes and Buy`
            df_yb = df_all.query("(start=='Y')and(tx=='BUY')and(ltrd!='BUY')")                        
            if(len(df_yb.index)>0):
                for idx,row in df_yb.iterrows():
                    row['idx'] = str(idx)
                    r = self.break_qty(row['one'], row['qty'])
                    self.send_orders(r, row)
                    self.ms.set_rng(row['task'], 'R' + row['idx'])
                    self.ms.set_rng(row['qty'], 'S' + row['idx'])
                    self.ms.set_rng("BUY", 'T' + row['idx'])

            # copy df with `No and Sell`
            df_ys = df_all.query("(start=='Y')and(tx=='SELL')and(ltrd!='SELL')")                        
            if(len(df_ys.index)>0):
                for idx,row in df_ys.iterrows():
                    row['idx'] = str(idx)
                    r = self.break_qty(row['one'], row['qty'])
                    self.send_orders(r, row)
                    self.ms.set_rng(row['tbid'], 'R' + row['idx'])
                    self.ms.set_rng(row['qty'], 'S' + row['idx'])
                    self.ms.set_rng("SELL", 'T' + row['idx'])

            # copy df with `No and Buy`
            df_nb = df_all.query("(start=='N')and(tx=='BUY')and(ltrd!='SELL')")                        
            if(len(df_nb.index)>0):
                for idx,row in df_nb.iterrows():
                    row['idx'] = str(idx)
                    r = self.break_qty(row['one'], row['qty'])
                    row['tx'] = 'SELL'
                    self.send_orders(r, row)
                    self.ms.set_rng(row['tbid'], 'R' + row['idx'])
                    self.ms.set_rng(row['qty'], 'S' + row['idx'])
                    self.ms.set_rng("SELL", 'T' + row['idx'])

            # copy df with `Yes and Buy`
            df_ns = df_all.query("(start=='N')and(tx=='SELL')and(ltrd!='BUY')")                        
            if(len(df_ns.index)>0):
                for idx,row in df_ns.iterrows():
                    row['idx'] = str(idx)
                    r = self.break_qty(row['one'], row['qty'])
                    row['tx'] = 'BUY'
                    self.send_orders(r, row)
                    self.ms.set_rng(row['task'], 'R' +  row['idx'])
                    self.ms.set_rng(row['qty'], 'S' +  row['idx'])
                    self.ms.set_rng("BUY", 'T' +  row['idx'])

            # copy df with `No and Selk`
            df_halt = df_all.query("(start!='Y')and(start!='N')and(ltrd!='HALT')")                        
            if(len(df_halt.index)>0):
                for idx,row in df_halt.iterrows():
                   row['idx'] = str(idx)
                   self.ms.set_rng("HALT", 'T' +  row['idx'])
            
        except BaseException as err:
            logging.exception("get_orders {}, {}".format(err, type(err)))  
    
    def run(self):                 
        try:
            while self.secs != dt.now().second:                                                
                self.set_price_to_sht()
                self.get_orders()
                self._sleep_till_next_sec()         
        except BaseException as err:
            logging.exception("run {}, {}".format(err, type(err)))            

Trade().run()