├── input
    ├── state
    ├── condition
    ├── contract
    ├── leverage
    ├── z19
    ├── M20
    ├── usd
    ├── setting
    └── apikey_real
├── data
    └── bitmex_bot.gif
├── .gitignore
├── curses-2.2.1+utf8-cp37-cp37m-win_amd64.whl
├── README.md
├── requirements.txt
├── LICENSE
├── ui.py
└── bitmex_bot.py


/input/state:
--------------------------------------------------------------------------------
1 | Opened


--------------------------------------------------------------------------------
/input/condition:
--------------------------------------------------------------------------------
1 | None


--------------------------------------------------------------------------------
/input/contract:
--------------------------------------------------------------------------------
1 | XBTH20


--------------------------------------------------------------------------------
/input/leverage:
--------------------------------------------------------------------------------
1 | 0
2 | 0


--------------------------------------------------------------------------------
/input/z19:
--------------------------------------------------------------------------------
1 | 9213.50
2 | 9214.00


--------------------------------------------------------------------------------
/input/M20:
--------------------------------------------------------------------------------
1 | 10959.50
2 | 10960.00


--------------------------------------------------------------------------------
/input/usd:
--------------------------------------------------------------------------------
1 | 10693.50
2 | 10694.00


--------------------------------------------------------------------------------
/input/setting:
--------------------------------------------------------------------------------
1 | 5
2 | 304.0
3 | -200.0


--------------------------------------------------------------------------------
/data/bitmex_bot.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/strader07/bitmex_algo_trader/HEAD/data/bitmex_bot.gif


--------------------------------------------------------------------------------
/input/apikey_real:
--------------------------------------------------------------------------------
1 | test
2 | bxz29HwfEVZGWfPkUTn356D_
3 | f2qC-8AHcN_C1gOj8yXRdM1C9UZy8R10C_SIR1KfDkcYpiZt


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Byte-compiled / optimized / DLL files
2 | __pycache__/
3 | *.py[cod]
4 | *$py.class
5 | *.pyc


--------------------------------------------------------------------------------
/curses-2.2.1+utf8-cp37-cp37m-win_amd64.whl:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/strader07/bitmex_algo_trader/HEAD/curses-2.2.1+utf8-cp37-cp37m-win_amd64.whl


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # bitmex_algo_trader
2 | Algorithmic trading bot using bitmex API with a simple UI in terminal
3 | <br/>
4 | <br/>
5 | <img src="data/bitmex_bot.gif"></img>


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
 1 | aiodns==1.1.1
 2 | aiofile==3.1.0
 3 | aiohttp==3.6.2
 4 | async-timeout==3.0.1
 5 | attrs==20.2.0
 6 | caio==0.6.1
 7 | cchardet==2.1.6
 8 | ccxt==1.34.26
 9 | certifi==2020.6.20
10 | cffi==1.14.2
11 | chardet==3.0.4
12 | cryptofeed==1.5.1
13 | cryptography==3.1
14 | idna==2.10
15 | keyboard==0.13.5
16 | multidict==4.7.6
17 | numpy==1.19.2
18 | pandas==1.1.2
19 | pycares==3.1.1
20 | pycparser==2.20
21 | python-dateutil==2.8.1
22 | pytz==2020.1
23 | requests==2.24.0
24 | six==1.15.0
25 | sortedcontainers==2.2.2
26 | typing-extensions==3.7.4.3
27 | urllib3==1.25.10
28 | websockets==8.1
29 | yapic.json==1.5.1
30 | yarl==1.1.0
31 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Jing Sun
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/ui.py:
--------------------------------------------------------------------------------
  1 | from tkinter import Spinbox, Label,Tk, Button, ttk
  2 | import ccxt,os,sys,threading
  3 | import bitmex_bot
  4 | 
  5 | if(os.path.exists('input/apikey_real')==False):
  6 |     print("Please make config file !")
  7 |     sys.exit()
  8 | f=open('input/apikey_real','r')
  9 | lines=f.readlines()
 10 | f.close
 11 | if(len(lines)!=3):
 12 |     print('Bad config!')
 13 |     sys.exit()
 14 |     
 15 | btmx = ccxt.bitmex({
 16 |     'apiKey': lines[1][:-1],
 17 |     'secret':lines[2],
 18 |     'enableRateLimit': False,
 19 |     'options': {
 20 |         'api-expires': 60,
 21 |     },
 22 |     #to resolve clock lack of synchronisation with server
 23 | })
 24 | 
 25 | if lines[0].strip() == 'test':
 26 |     btmx.urls['api'] = btmx.urls['test']
 27 | 
 28 | def g_hotkey_process():
 29 |     window = Tk()
 30 |     window.title("Real bot control")
 31 |     window.geometry('250x200')
 32 |     
 33 |     f=open('setting','r')
 34 |     Quantity=f.readline()[:-1]
 35 |     MaxDifference=f.readline()[:-1]
 36 |     MinDifference=f.readline()
 37 |     f.close()
 38 |     
 39 |     def SaveChange():
 40 |         f=open('input/setting','w')
 41 |         f.write(QtySpin.get()+'\n')
 42 |         f.write(MaxSpin.get()+'\n')
 43 |         f.write (MinSpin.get())
 44 |         f.close()
 45 |     def MaxChange():
 46 |         if(float(MaxSpin.get())<float(MinSpin.get())+1):
 47 |             MaxSpin.delete(0, "end")
 48 |             MaxSpin.insert(0, float(MinSpin.get())+1)
 49 |         SaveChange()
 50 |     def MinChange():
 51 |         if(float(MaxSpin.get())<float(MinSpin.get())+1):
 52 |             MinSpin.delete(0, "end")
 53 |             MinSpin.insert(0, float(MaxSpin.get())-1)
 54 |         SaveChange()
 55 |         
 56 |     QtyLabel = Label(window, text="Quantity")
 57 |     QtyLabel.grid(column=0, row=0)
 58 |     QtySpin = Spinbox(window, from_=1, to=500, width=7, command=SaveChange)
 59 |     QtySpin.delete(0, "end")
 60 |     QtySpin.insert(0, Quantity)
 61 |     QtySpin.grid(column=1,row=0)
 62 |         
 63 |     MaxLabel = Label(window, text="Max difference")
 64 |     MaxLabel.grid(column=0, row=1)
 65 |     MaxSpin = Spinbox(window,increment=0.5, from_=-200, to=500, width=7, command=MaxChange)
 66 |     MaxSpin.delete(0, "end")
 67 |     MaxSpin.insert(0, MaxDifference)
 68 |     MaxSpin.grid(column=1,row=1)
 69 |     
 70 |     MinLabel = Label(window, text="Min difference")
 71 |     MinLabel.grid(column=0, row=2)
 72 |     MinSpin = Spinbox(window,increment=0.5, from_=-200, to=500, width=7, command=MinChange)
 73 |     MinSpin.delete(0, "end")
 74 |     MinSpin.insert(0, MinDifference)
 75 |     MinSpin.grid(column=1,row=2)
 76 |     
 77 |     f=open('input/leverage','r')
 78 |     USDLeverage=f.readline()[:-1]
 79 |     M20Leverage=f.readline()
 80 |     f.close()
 81 |     
 82 |     label1=Label(window,text='XBTUSD Leverage')
 83 |     label1.grid(column=0,row=3)
 84 |     USDLeverageSpin = Spinbox(window,increment=1, from_=0, to=100, width=7)
 85 |     USDLeverageSpin.delete(0, "end")
 86 |     USDLeverageSpin.insert(0, USDLeverage)
 87 |     USDLeverageSpin.grid(column=1,row=3)  
 88 |     
 89 |     M20Label=Label(window,text='XBTM20 Leverage')
 90 |     M20Label.grid(column=0,row=4)
 91 |     M20LeverageSpin = Spinbox(window,increment=1, from_=0, to=100, width=7)
 92 |     M20LeverageSpin.delete(0, "end")
 93 |     M20LeverageSpin.insert(0, M20Leverage)
 94 |     M20LeverageSpin.grid(column=1,row=4)  
 95 |      
 96 |     def USDApplyLeverage():
 97 |         params={"symbol":'XBTUSD',"leverage":USDLeverageSpin.get()}
 98 |         btmx.private_post_position_leverage(params)
 99 |         f=open('input/leverage','r')
100 |         lines=f.readlines()
101 |         f.close()
102 |         lvs=USDLeverageSpin.get()+'\n'+lines[1]
103 |         f=open('input/leverage','w')
104 |         f.write(lvs)
105 |         f.close()
106 |         
107 |     def M20ApplyLeverage():
108 |         f=open('input/contract','r')
109 |         contract=f.readlines()[0]
110 |         f.close()
111 |         params={"symbol":contract,"leverage":M20LeverageSpin.get()}
112 |         btmx.private_post_position_leverage(params)
113 |         f=open('input/leverage','r')
114 |         lines=f.readlines()
115 |         f.close()
116 |         lvs=lines[0]+M20LeverageSpin.get()
117 |         f=open('input/leverage','w')
118 |         f.write(lvs)
119 |         f.close()
120 |         
121 |     USDLeverageButton=Button(window,text='Apply', command=USDApplyLeverage)
122 |     USDLeverageButton.grid(column=2,row=3)
123 |     M20LeverageButton=Button(window,text='Apply', command=M20ApplyLeverage)
124 |     M20LeverageButton.grid(column=2,row=4)
125 |        
126 |     label3=Label(window,text='Second Contract')
127 |     label3.grid(column=0,row=5)    
128 |     ContractCombo= ttk.Combobox(window, width = 8, state='readonly')
129 |     ContractCombo['values'] = ('XBTH20','XBTM20')
130 |     ContractCombo.grid(column = 1, row = 5) 
131 |     f=open('input/contract','r')
132 |     contract=f.readlines()[0]
133 |     f.close()
134 |     if(contract=='XBTM20'):
135 |         ContractCombo.current(0)
136 |     else:
137 |         ContractCombo.current(1)
138 |     
139 |     def ContractApply():
140 |         M20Label['text']=ContractCombo.get()+' Leverage'
141 |         f=open('input/contract','w')
142 |         f.write(ContractCombo.get())
143 |         f.close()
144 |         
145 |     ContractButton=Button(window,text='Apply', command=ContractApply)
146 |     ContractButton.grid(column=2,row=5)
147 |     
148 |     ths=[]
149 |     def openUsd():
150 |         Quantity=QtySpin.get()
151 |         bitmex_bot.bitmex_post_order('XBTUSD','Buy','Market',Quantity,'')
152 |     def openM20():
153 |         Quantity=QtySpin.get()
154 |         bitmex_bot.bitmex_post_order(contract,'Sell','Market',Quantity,'')
155 |     def OpenTrade():
156 |         f=open('input/contract','r')
157 |         contract=f.readlines()[0]
158 |         f.close()
159 |         th=threading.Thread(target=openUsd)
160 |         ths.append(th)
161 |         th1=threading.Thread(target=openM20)
162 |         ths.append(th1)
163 |         th.start()
164 |         th1.start()
165 |         
166 |         f=open('input/state','w')
167 |         f.write('Opened')
168 |         f.close()
169 | 
170 |     def closeUsd():
171 |         Quantity=QtySpin.get()
172 |         bitmex_bot.bitmex_post_order('XBTUSD','Sell','Market',Quantity,'') 
173 |     def closeM20():
174 |         Quantity=QtySpin.get()
175 |         bitmex_bot.bitmex_post_order(contract,'Buy','Market',Quantity,'') 
176 |     def CloseTrade():
177 |         f=open('input/contract','r')
178 |         contract=f.readlines()[0]
179 |         f.close()
180 |         th=threading.Thread(target=closeM20)
181 |         ths.append(th)
182 |         th1=threading.Thread(target=closeUsd)
183 |         ths.append(th1)
184 |         th.start()
185 |         th1.start()  
186 |         f=open('input/state','w')
187 |         f.write('Closed')
188 |         f.close()
189 |         
190 |     OpenButton=Button(window,text="Open",command=OpenTrade)
191 |     OpenButton.grid(column=0,row=6)
192 |     CloseButton=Button(window,text="Close",command=CloseTrade)
193 |     CloseButton.grid(column=1,row=6)
194 |     
195 |     window.mainloop()  
196 | 
197 | def main(): 
198 |     g_hotkey_process()
199 |     
200 | if __name__ == '__main__':
201 |     main()
202 | 


--------------------------------------------------------------------------------
/bitmex_bot.py:
--------------------------------------------------------------------------------
  1 | from cryptofeed.callback import BookCallback
  2 | from cryptofeed import FeedHandler
  3 | 
  4 | from cryptofeed.exchanges import Bitmex
  5 | from cryptofeed.defines import L2_BOOK, BID, ASK
  6 | import ccxt, time, os, curses, keyboard
  7 | from datetime import datetime 
  8 | from tkinter import Spinbox, Label,Tk
  9 | import threading,sys
 10 | import ui
 11 | 
 12 | f=open('input/setting','w')
 13 | f.write('1'+'\n')
 14 | f.write('300'+'\n')
 15 | f.write('-200')
 16 | f.close()
 17 | 
 18 | rows=10
 19 | width=100
 20 | first_col_width=90
 21 | first_blank_col=""
 22 | for i in range(first_col_width):
 23 |     first_blank_col+=" "
 24 | 
 25 | if(os.path.exists('input/apikey_real')==False):
 26 |     print("Please make config file !")
 27 |     sys.exit()
 28 | f=open('input/apikey_real','r')
 29 | lines=f.readlines()
 30 | f.close
 31 | if(len(lines)!=3):
 32 |     print('Bad config!')
 33 |     sys.exit()
 34 |     
 35 | f=open('input/state','w')
 36 | f.write('None')
 37 | f.close()
 38 | 
 39 | btmx = ccxt.bitmex({
 40 |     'apiKey': lines[1][:-1],
 41 |     'secret':lines[2],
 42 |     'enableRateLimit': True,
 43 |     #addition for compturer clock not synchronised for real API
 44 |     'options': {
 45 |         'api-expires': 60,
 46 |     },
 47 | })
 48 | 
 49 | if lines[0].strip() == 'test':
 50 |     btmx.urls['api'] = btmx.urls['test']
 51 | 
 52 | f=open('input/contract','r')
 53 | contract=f.readlines()[0]
 54 | f.close()
 55 |         
 56 | params={"symbol":'XBTUSD',"leverage":'0'}
 57 | # btmx.private_post_position_leverage(params)
 58 | params={"symbol":contract,"leverage":'0'}
 59 | # btmx.private_post_position_leverage(params)
 60 | f=open('input/leverage','w')
 61 | f.write('0'+'\n')
 62 | f.write('0')
 63 | f.close()
 64 | 
 65 | def n(strr,n):
 66 |     if(len(strr)<n):
 67 |         for i in range(n-len(strr)):
 68 |             strr+=(' ')
 69 |     return strr
 70 | 
 71 | async def xbtusd_book(feed, pair, book, timestamp, receipt_timestamp):
 72 |     global width
 73 |     # Need flip the dict, but last element is first
 74 |     Max_book=len(book[BID])-1    
 75 |     fmt2="{:11.2f}"  
 76 |     stdscr = curses.initscr() #Make a screen in terminal window
 77 |     #Title
 78 |     stdscr.addstr(0,0,'                                    XBTUSD                                        ')
 79 |     stdscr.addstr(1,0,"  [ QTY_SUM ]|   [ QTY ]   |   [ BID ]   |   [ ASK ]   |   [ QTY ]   | [ QTY_SUM ]")
 80 |     stdscr.addstr(2,0,'-------------+-------------+-------------+-------------+-------------+-------------')
 81 |     # Add Bids, Asks to table
 82 |     bid_sum=0
 83 |     ask_sum=0
 84 |     for i in range(rows):
 85 |         bid_sum+=book[BID].items()[Max_book-i][1]
 86 |         ask_sum+=book[ASK].items()[i][1]
 87 |         stdscr.addstr(i+3,0,fmt2.format(bid_sum)+' | '+\
 88 |                       fmt2.format(book[BID].items()[Max_book-i][1])+' | '+\
 89 |                       fmt2.format(book[BID].items()[Max_book-i][0])+' | '+\
 90 |                       fmt2.format(book[ASK].items()[i][0])+' | '+\
 91 |                       fmt2.format(book[ASK].items()[i][1])+' | '+\
 92 |                       fmt2.format(ask_sum))
 93 |         
 94 |     usd_bid="{:6.2f}".format(book[BID].items()[Max_book][0])
 95 |     usd_ask="{:6.2f}".format(book[ASK].items()[0][0])    
 96 |     stdscr.addstr(rows*2+8,0,n("XBTUSD Bid:"+usd_bid+" XBTUSD Ask:"+usd_ask,width))
 97 |     
 98 |     stdscr.refresh()
 99 |     bid="{:6.2f}".format(book[BID].items()[Max_book][0])
100 |     ask="{:6.2f}".format(book[ASK].items()[0][0])
101 |     f=open('input/usd','w')
102 |     f.write(bid+"\n")
103 |     f.write(ask)
104 |     f.close()
105 |     
106 | async def xbtM20_book(feed, pair, book, timestamp, receipt_timestamp):
107 |     f=open('input/contract','r')
108 |     contract=f.readlines()[0]
109 |     f.close()
110 | 
111 |     global width
112 |     # Need flip the dict, but last element is first
113 |     Max_book=len(book[BID])-1    
114 |     fmt2="{:11.2f}"  
115 |     stdscr = curses.initscr() #Make a screen in terminal window
116 |     #Title
117 |     stdscr.addstr(rows+3,0,n(' ',width))
118 |     stdscr.addstr(rows+4,0,'                                    '+contract+'                                        ')
119 |     stdscr.addstr(rows+5,0,"  [ QTY_SUM ]|   [ QTY ]   |   [ BID ]   |   [ ASK ]   |   [ QTY ]   | [ QTY_SUM ]")
120 |     stdscr.addstr(rows+6,0,'------------+-------------+-------------+-------------+-------------+-------------')
121 |     # Add Bids, Asks to table
122 |     bid_sum=0
123 |     ask_sum=0
124 |     for i in range(rows):
125 |         bid_sum+=book[BID].items()[Max_book-i][1]
126 |         ask_sum+=book[ASK].items()[i][1]
127 |         stdscr.addstr(i+rows+7,0,fmt2.format(bid_sum)+' | '+\
128 |                       fmt2.format(book[BID].items()[Max_book-i][1])+' | '+\
129 |                       fmt2.format(book[BID].items()[Max_book-i][0])+' | '+\
130 |                       fmt2.format(book[ASK].items()[i][0])+' | '+\
131 |                       fmt2.format(book[ASK].items()[i][1])+' | '+\
132 |                       fmt2.format(ask_sum))
133 |     
134 |     f=open('input/usd','r')
135 |     usd_bid=f.readline()[:-1]
136 |     usd_ask=f.readline()
137 |     f.close()
138 |     
139 |     M20_bid="{:6.2f}".format(book[BID].items()[Max_book][0])
140 |     M20_ask="{:6.2f}".format(book[ASK].items()[0][0])
141 | 
142 |     f=open('input/M20','w')
143 |     f.write(M20_bid+"\n")
144 |     f.write(M20_ask)
145 |     f.close()
146 |     
147 |     stdscr.addstr(rows*2+7,0,n(' ',width))
148 |     stdscr.addstr(rows*2+9,0,n(contract+" Bid:"+M20_bid+" "+contract+" Ask:"+M20_ask,width))
149 |     
150 |     diff_open="{:6.2f}".format(float(M20_bid)-float(usd_ask))
151 |     diff_close="{:6.2f}".format(float(M20_ask)-float(usd_bid))
152 |     stdscr.addstr(rows*2+10,0,n("Open Difference ( XBTM20_bid - XBTUSD_ask ): "+diff_open,width))
153 |     stdscr.addstr(rows*2+11,0,n("Close Difference ( XBTM20_ask - XBTUSD_bid ): "+diff_close,width))
154 |     
155 |     f=open('input/setting','r')
156 |     qty=f.readline()[:-1]
157 |     max_diff=f.readline()[:-1]
158 |     min_diff=f.readline()
159 |     f.close()
160 |     stdscr.addstr(rows*2+12,0,n("Quantity:"+qty+" Max Difference:"+max_diff+" Min Difference:"+min_diff,width))
161 |     
162 |     f=open('input/state','r')
163 |     state=f.readline()
164 |     f.close()
165 |     state="Current trading state: "+state+"     "
166 |     
167 |     cond=''
168 |     if float(diff_open)>float(max_diff) and float(diff_close)<float(min_diff):
169 |         stdscr.addstr(rows*2+13,0,n(state+"Open/Close condition satisfied! "+diff_open+">"+max_diff,width))
170 |         cond='OpenClose'
171 |     elif float(diff_open)>float(max_diff):
172 |         stdscr.addstr(rows*2+13,0,n(state+"Open condition satisfied! "+diff_open+">"+max_diff,width))
173 |         cond='Open'
174 |     elif float(diff_close)<float(min_diff):
175 |         stdscr.addstr(rows*2+13,0,n(state+"Close condition satisfied! "+diff_close+"<"+min_diff,width))
176 |         cond='Close'
177 |     else:
178 |         stdscr.addstr(rows*2+13,0,n(state+"None condition satisfied!",width))
179 |         cond='None'
180 |     stdscr.addstr(rows*2+14,0,n(' ',width))
181 |     stdscr.addstr(rows*2+15,0,n(' ',width))   
182 |     stdscr.refresh()
183 |     
184 |     f=open('input/condition','w')
185 |     f.write(cond)
186 |     f.close()    
187 |   
188 | def log(data):
189 |     with open('input/real_log.txt', 'a') as f:
190 |         f.write(str(datetime.now()) + ' ' + str(data) + '\n')
191 | 
192 | def handle_timeout(e):
193 |     sstr = 'timeout='
194 |     pos = e.args[0].find(sstr)
195 |     if pos > 0:
196 |         timeout = int(e.args[0][pos + len(sstr):-1])
197 |         time.sleep(timeout)
198 |     else:
199 |         time.sleep(2)
200 |         
201 | def bitmex_post_order(symbol,orderSide, ordType, orderQty, orderPrice):
202 |     if ordType=="Market":
203 |         params={"symbol":symbol,\
204 |                 "side":orderSide,\
205 |                 "orderQty":orderQty,\
206 |                 "ordType":"Market"}
207 |     elif ordType=="Limit":
208 |         params={"symbol":symbol,\
209 |                 "side":orderSide,\
210 |                 "orderQty":orderQty,\
211 |                 "ordType":"Limit",\
212 |                 "price":orderPrice}
213 |     res = None
214 |     while not res:
215 |         try:
216 |             res = btmx.private_post_order(params)
217 |             log(res)
218 |         except Exception as e:
219 |             log(e)
220 |             handle_timeout(e)
221 |     return res  
222 | 
223 | def bitmex_close_pos(symbol):
224 |     res = None
225 |     params = {'symbol': symbol, 'execInst': 'Close'}
226 |     while not res:
227 |         try:
228 |             res = btmx.private_post_order(params)
229 |             log(res)
230 |         except Exception as e:
231 |             log(e)
232 |             handle_timeout(e)    
233 | def g_hotkey_process():
234 |     window = Tk()
235 |     window.title(":)")
236 |     window.geometry('250x100')
237 |     
238 |     f=open('input/setting','r')
239 |     Quantity=f.readline()[:-1]
240 |     MaxDifference=f.readline()[:-1]
241 |     MinDifference=f.readline()
242 |     f.close()
243 |     
244 |     def SaveChange():
245 |         f=open('input/setting','w')
246 |         f.write(QtySpin.get()+'\n')
247 |         f.write(MaxSpin.get()+'\n')
248 |         f.write(MinSpin.get())
249 |         f.close()
250 |     
251 |     QtyLabel = Label(window, text="Quantity")
252 |     QtyLabel.grid(column=0, row=0)
253 |     QtySpin = Spinbox(window, from_=1, to=2, width=7, command=SaveChange) # limited to 2 during testing
254 |     QtySpin.delete(0, "end")
255 |     QtySpin.insert(0, Quantity)
256 |     QtySpin.grid(column=1,row=0)
257 |         
258 |     MaxLabel = Label(window, text="Max difference")
259 |     MaxLabel.grid(column=0, row=1)
260 |     MaxSpin = Spinbox(window, from_=-200, to=500, width=7, command=SaveChange)
261 |     MaxSpin.delete(0, "end")
262 |     MaxSpin.insert(0, MaxDifference)
263 |     MaxSpin.grid(column=1,row=1)
264 |     
265 |     MinLabel = Label(window, text="Min difference")
266 |     MinLabel.grid(column=0, row=2)
267 |     MinSpin = Spinbox(window, from_=-200, to=500, width=7, command=SaveChange)
268 |     MinSpin.delete(0, "end")
269 |     MinSpin.insert(0, MinDifference)
270 |     MinSpin.grid(column=1,row=2)
271 |     
272 |     window.mainloop()  
273 | 
274 | def trade():
275 |     f=open('input/condition','r')
276 |     cond=f.readline()
277 |     f.close()
278 |     
279 |     stdscr1 = curses.initscr() 
280 |     stdscr1.addstr(rows*2+14,0,n('',width))
281 |     stdscr1.addstr(rows*2+15,0,n(cond+" "+str(datetime.now()),width))
282 |     stdscr1.refresh() 
283 |     
284 |     f=open('input/setting','r')
285 |     Quantity=f.readline()[:-1]
286 |     f.close()
287 |     
288 |     f=open('input/state','r')
289 |     state=f.readline()
290 |     f.close()
291 |     
292 |     f=open('input/contract','r')
293 |     contract=f.readlines()[0]
294 |     f.close()
295 | 
296 |     tths=[]
297 | 
298 |     def openUsd():
299 |         bitmex_post_order('XBTUSD','Buy','Market',Quantity,'')
300 |     def openM20():
301 |         bitmex_post_order(contract,'Sell','Market',Quantity,'')
302 |     def closeUsd():
303 |         bitmex_post_order('XBTUSD','Sell','Market',Quantity,'')
304 |     def closeM20():
305 |         bitmex_post_order(contract,'Buy','Market',Quantity,'')
306 |         
307 |     if((cond=='Open' or cond=='OpenClose') and state!='Opened'):
308 |         th=threading.Thread(target=openUsd)
309 |         tths.append(th)
310 |         th1=threading.Thread(target=openM20)
311 |         tths.append(th1)
312 |         th.start()
313 |         th1.start()
314 |         f=open('input/state','w')
315 |         f.write('Opened')
316 |         f.close()
317 |     elif((cond=='Close' or cond=='OpenClose') and state=='Opened'):
318 |         th=threading.Thread(target=closeM20)
319 |         tths.append(th)
320 |         th1=threading.Thread(target=closeUsd)
321 |         tths.append(th1)
322 |         th.start()
323 |         th1.start()  
324 |         f=open('input/state','w')
325 |         f.write('Closed')
326 |         f.close()
327 |         
328 |     t=threading.Timer(0.1, trade)
329 |     t.start()
330 |     
331 | import platform    
332 | def main(): 
333 |     f=open('input/contract','r')
334 |     contract=f.readlines()[0]
335 |     f.close()
336 |     
337 |     print("Hello XBTUSD, "+contract+" ! Orderbooks loading....") 
338 |     
339 |     if(platform.system()=='Windows'):
340 |         keyboard.add_hotkey('g', ui.g_hotkey_process)
341 |         os.system('mode con: cols=100 lines='+str((rows+4)*2+10))
342 |     
343 |     ths=[]
344 |     th=threading.Thread(target=trade)
345 |     ths.append(th)
346 |     th.start()
347 |     
348 |     f1 = FeedHandler()
349 |     usd_handler=Bitmex(pairs=['XBTUSD'], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(xbtusd_book)})
350 |     f1.add_feed(usd_handler)
351 |     
352 |     M20_handler=Bitmex(pairs=[contract], channels=[L2_BOOK], callbacks={L2_BOOK: BookCallback(xbtM20_book)})
353 |     f1.add_feed(M20_handler)
354 |     f1.run()
355 |     
356 | if __name__ == '__main__':
357 |     main()
358 |     curses.endwin() #Close screen
359 | 


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