API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 21st, 2018
71
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 22.28 KB | None | 0 0
raw download clone embed print report
  1. from urllib.request import Request, urlopen
  2. import json
  3. lst = list()
  4. url="https://max-api.maicoin.com/api/v2/tickers"
  5. req = Request(url, headers={'User-Agent': 'Mozilla/5.0'})
  6. connection = urlopen(req).read()
  7. data = connection.decode()
  8. dic = json.loads(data)
  9. lst = list()
  10. #--------------------------------------------------------------
  11. # base price
  12. #--------------------------------------------------------------
  13. BTC_USDT = float(dic["btcusdt"]["buy"])
  14. ETH_USDT = float(dic["ethusdt"]["buy"])
  15. MAX_USDT = float(dic["maxusdt"]["buy"])
  16. #TWD_USDT = 1 / float(dic["usdttwd"]["buy"])
  17. TWDT_USDT= 1 / float(dic["usdttwdt"]["buy"])
  18. #--------------------------------------------------------------
  19. # ((( 1 ETH )))
  20. #--------------------------------------------------------------
  21. ETH_USDT= float(dic["ethusdt"]["sell"])
  22. ETH_BTC = float(dic["ethbtc"]["sell"]) * BTC_USDT
  23. ETH_t_min = {
  24. "ethbtc" : ETH_BTC,
  25. "ethusdt": ETH_USDT,
  26. }
  27. miniETH = min(ETH_t_min, key=ETH_t_min.get)
  28. minimum = min(ETH_t_min.values())
  29. ETH_USDT= float(dic["ethusdt"]["buy"])
  30. ETH_BTC = float(dic["ethbtc"]["buy"]) * BTC_USDT
  31. ETH_t_max = {
  32. "ethbtc" : ETH_BTC,
  33. "ethusdt": ETH_USDT,
  34. }
  35. maxiETH = max(ETH_t_max, key=ETH_t_max.get)
  36. maximum = max(ETH_t_max.values())
  37. ETH_RES = ( maximum * 100 ) / minimum
  38. if ETH_RES > 100.7 :
  39. lst.append(ETH_RES)
  40. def ETH():
  41. print("")
  42. print("buy from",miniETH)
  43. print("sell to",maxiETH)
  44. print("")
  45. #--------------------------------------------------------------
  46. # ((( 2 BTC )))
  47. #--------------------------------------------------------------
  48. BTC_USDT = float(dic["btcusdt"]["sell"])
  49. #BTC_TWD = float(dic["btctwd"]["sell"]) * TWD_USDT
  50. BTC_TWDT = float(dic["btctwdt"]["sell"]) * TWDT_USDT
  51. BTC_t_min = {
  52. "btcusdt" : BTC_USDT,
  53. # "btctwd" : BTC_TWD,
  54. "btctwdt" : BTC_TWDT,
  55. }
  56. miniBTC = min(BTC_t_min, key=BTC_t_min.get)
  57. minimum = min(BTC_t_min.values())
  58. BTC_USDT = float(dic["btcusdt"]["buy"])
  59. #BTC_TWD = float(dic["btctwd"]["buy"]) * TWD_USDT
  60. BTC_TWDT = float(dic["btctwdt"]["buy"]) * TWDT_USDT
  61. BTC_t_max = {
  62. "btcusdt" : BTC_USDT,
  63. # "btctwd" : BTC_TWD,
  64. "btctwdt" : BTC_TWDT,
  65. }
  66. maximum = max(BTC_t_max.values())
  67. maxiBTC = max(BTC_t_max, key=BTC_t_max.get)
  68. BTC_RES = ( maximum * 100 ) / minimum
  69. if BTC_RES > 100.7 :
  70. lst.append(BTC_RES)
  71. def BTC():
  72. print("")
  73. print("buy from",miniBTC)
  74. print("sell to",maxiBTC)
  75. print("")
  76. #--------------------------------------------------------------
  77. # ((( 3 BCH )))
  78. #--------------------------------------------------------------
  79. BCH_USDT= float(dic["bchusdt"]["sell"])
  80. #BCH_TWD = float(dic["bchtwd"]["sell"]) * TWD_USDT
  81. #BCH_TWDT = float(dic["bchtwdt"]["sell"]) * TWDT_USDT
  82. BCH_MAX = float(dic["bchmax"]["sell"]) * MAX_USDT
  83. BCH_t_min = {
  84. "bchusdt" : BCH_USDT,
  85. # "bchtwd" : BCH_TWD,
  86. # "bchtwdt": BCH_TWDT,
  87. "bchmax" : BCH_MAX
  88. }
  89. miniBCH = min(BCH_t_min, key=BCH_t_min.get)
  90. minimum = min(BCH_t_min.values())
  91. BCH_USDT= float(dic["bchusdt"]["buy"])
  92. #BCH_TWD = float(dic["bchtwd"]["buy"]) * TWD_USDT
  93. #BCH_TWDT = float(dic["bchtwdt"]["buy"]) * TWDT_USDT
  94. BCH_MAX = float(dic["bchmax"]["buy"]) * MAX_USDT
  95. BCH_t_max = {
  96. "bchusdt" : BCH_USDT,
  97. # "bchtwd" : BCH_TWD,
  98. # "BCH_TWDT": BCH_TWDT,
  99. "bchmax" : BCH_MAX
  100. }
  101. maxiBCH = max(BCH_t_max, key=BCH_t_max.get)
  102. maximum = max(BCH_t_max.values())
  103. BCH_RES = ( maximum * 100 ) / minimum
  104. if BCH_RES > 100.7 :
  105. lst.append(BCH_RES)
  106. def BCH():
  107. print("")
  108. print("buy from",miniBCH)
  109. print("sell to",maxiBCH)
  110. print("")
  111. #--------------------------------------------------------------
  112. # ((( 4 LTC )))
  113. #--------------------------------------------------------------
  114. LTC_USDT= float(dic["ltcusdt"]["sell"])
  115. #LTC_TWD = float(dic["ltctwd"]["sell"]) * TWD_USDT
  116. #LTC_TWDT = float(dic["ltctwdt"]["sell"]) * TWDT_USDT
  117. LTC_MAX = float(dic["ltcmax"]["sell"]) * MAX_USDT
  118. LTC_t_min = {
  119. "ltcusdt" : LTC_USDT,
  120. # "ltctwd" : LTC_TWD,
  121. # "ltctwdt": LTC_TWDT,
  122. "ltcmax" : LTC_MAX
  123. }
  124. miniLTC = min(LTC_t_min, key=LTC_t_min.get)
  125. minimum = min(LTC_t_min.values())
  126. LTC_USDT= float(dic["ltcusdt"]["buy"])
  127. #LTC_TWD = float(dic["ltctwd"]["buy"]) * TWD_USDT
  128. #LTC_TWDT = float(dic["ltctwdt"]["buy"]) * TWDT_USDT
  129. LTC_MAX = float(dic["ltcmax"]["buy"]) * MAX_USDT
  130. LTC_t_max = {
  131. "ltcusdt" : LTC_USDT,
  132. # "ltctwd" : LTC_TWD,
  133. # "ltctwdt": LTC_TWDT,
  134. "ltcmax" : LTC_MAX
  135. }
  136. maxiLTC = max(LTC_t_max, key=LTC_t_max.get)
  137. maximum = max(LTC_t_max.values())
  138. LTC_RES = ( maximum * 100 ) / minimum
  139. if LTC_RES > 100.7 :
  140. lst.append(LTC_RES)
  141. def LTC():
  142. print("")
  143. print("buy from",miniLTC)
  144. print("sell to",maxiLTC)
  145. print("")
  146. #--------------------------------------------------------------
  147. # ((( 5 MITH )))
  148. #--------------------------------------------------------------
  149. MITH_USDT = float(dic["mithusdt"]["sell"])
  150. MITH_BTC = float(dic["mithbtc"]["sell"]) * BTC_USDT
  151. MITH_ETH = float(dic["mitheth"]["sell"]) * ETH_USDT
  152. #MITH_TWD = float(dic["mithtwd"]["sell"]) * TWD_USDT
  153. #MITH_TWDT = float(dic["mithtwdt"]["sell"])* TWDT_USDT
  154. MITH_MAX = float(dic["mithmax"]["sell"])* MAX_USDT
  155. MITH_t_min = {
  156. "mithusdt" : MITH_USDT,
  157. "mithbtc" : MITH_BTC,
  158. "mitheth" : MITH_ETH,
  159. # "mithtwd" : MITH_TWD,
  160. # "mithtwdt" : MITH_TWDT,
  161. "mithmax" : MITH_MAX,
  162. }
  163. miniMITH = min(MITH_t_min, key=MITH_t_min.get)
  164. minimum = min(MITH_t_min.values())
  165. MITH_USDT = float(dic["mithusdt"]["buy"])
  166. MITH_BTC = float(dic["mithbtc"]["buy"]) * BTC_USDT
  167. MITH_ETH = float(dic["mitheth"]["buy"]) * ETH_USDT
  168. #MITH_TWD = float(dic["mithtwd"]["buy"]) * TWD_USDT
  169. #MITH_TWDT = float(dic["mithtwdt"]["buy"])* TWDT_USDT
  170. MITH_MAX = float(dic["mithmax"]["buy"])* MAX_USDT
  171. MITH_t_max = {
  172. "mithusdt" : MITH_USDT,
  173. "mithbtc" : MITH_BTC,
  174. "mitheth" : MITH_ETH,
  175. # "mithtwd" : MITH_TWD,
  176. # "mithtwdt" : MITH_TWDT,
  177. "mithmax" : MITH_MAX,
  178. }
  179. maximum = max(MITH_t_max.values())
  180. maxiMITH = max(MITH_t_max, key=MITH_t_max.get)
  181. MITH_RES = ( maximum * 100 ) / minimum
  182. if MITH_RES > 100.7 :
  183. lst.append(MITH_RES)
  184. def MITH():
  185. print("")
  186. print("buy from",miniMITH)
  187. print("sell to",maxiMITH)
  188. print("")
  189. #--------------------------------------------------------------
  190. # ((( 6 XRP )))
  191. #--------------------------------------------------------------
  192. #XRP_TWD = float(dic["xrptwd"]["sell"]) * TWD_USDT
  193. XRP_MAX = float(dic["xrpmax"]["sell"]) * MAX_USDT
  194. XRP_USDT= float(dic["xrpusdt"]["sell"])
  195. XRP_t_min = {
  196. # "xrptwd" : XRP_TWD,
  197. "xrpmax" : XRP_MAX,
  198. "xrpusdt": XRP_USDT
  199. }
  200. miniXRP = min(XRP_t_min, key=XRP_t_min.get)
  201. minimum = min(XRP_t_min.values())
  202. #XRP_TWD = float(dic["xrptwd"]["buy"]) * TWD_USDT
  203. XRP_MAX = float(dic["xrpmax"]["buy"]) * MAX_USDT
  204. XRP_USDT= float(dic["xrpusdt"]["buy"])
  205. XRP_t_max = {
  206. # "xrptwd" : XRP_TWD,
  207. "xrpmax" : XRP_MAX,
  208. "xrpusdt": XRP_USDT
  209. }
  210. maxiXRP = max(XRP_t_max, key=XRP_t_max.get)
  211. maximum = max(XRP_t_max.values())
  212. XRP_RES = ( maximum * 100 ) / minimum
  213. if XRP_RES > 100.7 :
  214. lst.append(XRP_RES)
  215. def XRP():
  216. print("")
  217. print("buy from",miniXRP)
  218. print("sell to",maxiXRP)
  219. print("")
  220. #--------------------------------------------------------------
  221. # ((( 7 MAX )))
  222. #--------------------------------------------------------------
  223. MAX_USDT = float(dic["maxusdt"]["sell"])
  224. MAX_BTC = float(dic["maxbtc"]["sell"]) * BTC_USDT
  225. MAX_ETH = float(dic["maxeth"]["sell"]) * ETH_USDT
  226. MAX_TWDT = float(dic["maxtwdt"]["sell"]) * TWDT_USDT
  227. MAX_t_min = {
  228. "maxusdt": MAX_USDT,
  229. "maxbtc" : MAX_BTC,
  230. "maxeth" : MAX_ETH,
  231. "maxtwdt": MAX_TWDT
  232. }
  233. miniMAX = min(MAX_t_min, key=MAX_t_min.get)
  234. minimum = min(MAX_t_min.values())
  235. MAX_USDT = float(dic["maxusdt"]["buy"])
  236. MAX_BTC = float(dic["maxbtc"]["buy"]) * BTC_USDT
  237. MAX_ETH = float(dic["maxeth"]["buy"]) * ETH_USDT
  238. MAX_TWDT = float(dic["maxtwdt"]["buy"]) * TWDT_USDT
  239. MAX_t_max = {
  240. "maxusdt": MAX_USDT,
  241. "maxbtc" : MAX_BTC,
  242. "maxeth" : MAX_ETH,
  243. "maxtwdt": MAX_TWDT
  244. }
  245. maximum = max(MAX_t_max.values())
  246. maxiMAX = max(MAX_t_max, key=MAX_t_max.get)
  247. MAX_RES = ( maximum * 100 ) / minimum
  248. if MAX_RES > 100.7 :
  249. lst.append(MAX_RES)
  250. def MAX():
  251. print("")
  252. print("buy from",miniMAX)
  253. print("sell to",maxiMAX)
  254. print("")
  255. #--------------------------------------------------------------
  256. # ((( 8 TRX )))
  257. #--------------------------------------------------------------
  258. TRX_USDT = float(dic["trxusdt"]["sell"])
  259. TRX_BTC = float(dic["trxbtc"]["sell"]) * BTC_USDT
  260. TRX_ETH = float(dic["trxeth"]["sell"]) * ETH_USDT
  261. #TRX_TWD = float(dic["trxtwd"]["sell"]) * TWD_USDT
  262. TRX_TWDT = float(dic["trxtwdt"]["sell"])* TWDT_USDT
  263. TRX_MAX = float(dic["trxmax"]["sell"])* MAX_USDT
  264. TRX_t_min = {
  265. "trxusdt" : TRX_USDT,
  266. "trxbtc" : TRX_BTC,
  267. "trxeth" : TRX_ETH,
  268. # "trxtwd" : TRX_TWD,
  269. "trxtwdt" : TRX_TWDT,
  270. "trxmax" : TRX_MAX,
  271. }
  272. miniTRX = min(TRX_t_min, key=TRX_t_min.get)
  273. minimum = min(TRX_t_min.values())
  274. TRX_USDT = float(dic["trxusdt"]["buy"])
  275. TRX_BTC = float(dic["trxbtc"]["buy"]) * BTC_USDT
  276. TRX_ETH = float(dic["trxeth"]["buy"]) * ETH_USDT
  277. #TRX_TWD = float(dic["trxtwd"]["buy"]) * TWD_USDT
  278. TRX_TWDT = float(dic["trxtwdt"]["buy"])* TWDT_USDT
  279. TRX_MAX = float(dic["trxmax"]["buy"])* MAX_USDT
  280. TRX_t_max = {
  281. "trxusdt" : TRX_USDT,
  282. "trxbtc" : TRX_BTC,
  283. "trxeth" : TRX_ETH,
  284. # "trxtwd" : TRX_TWD,
  285. "trxtwdt" : TRX_TWDT,
  286. "trxmax" : TRX_MAX,
  287. }
  288. maximum = max(TRX_t_max.values())
  289. maxiTRX = max(TRX_t_max, key=TRX_t_max.get)
  290. TRX_RES = ( maximum * 100 ) / minimum
  291. if TRX_RES > 100.7 :
  292. lst.append(TRX_RES)
  293. def TRX():
  294. print("")
  295. print("buy from",miniTRX)
  296. print("sell to",maxiTRX)
  297. print("")
  298. #--------------------------------------------------------------
  299. # ((( 9 CCXT )))
  300. #--------------------------------------------------------------
  301. CCXT_USDT = float(dic["cccxusdt"]["sell"])
  302. CCXT_BTC = float(dic["cccxbtc"]["sell"]) * BTC_USDT
  303. #CCXT_ETH = float(dic["cccxeth"]["sell"]) * ETH_USDT
  304. #CCXT_TWD = float(dic["cccxtwd"]["sell"]) * TWD_USDT
  305. CCXT_TWDT = float(dic["cccxtwdt"]["sell"])* TWDT_USDT
  306. CCXT_MAX = float(dic["cccxmax"]["sell"])* MAX_USDT
  307. CCXT_t_min = {
  308. "cccxusdt" : CCXT_USDT,
  309. "cccxbtc" : CCXT_BTC,
  310. # "cccxeth" : CCXT_ETH,
  311. # "cccxtwd" : CCXT_TWD,
  312. "cccxtwdt" : CCXT_TWDT,
  313. "cccxmax" : CCXT_MAX,
  314. }
  315. miniCCXT = min(CCXT_t_min, key=CCXT_t_min.get)
  316. minimum = min(CCXT_t_min.values())
  317. CCXT_USDT = float(dic["cccxusdt"]["buy"])
  318. CCXT_BTC = float(dic["cccxbtc"]["buy"]) * BTC_USDT
  319. #CCXT_ETH = float(dic["cccxeth"]["buy"]) * ETH_USDT
  320. #CCXT_TWD = float(dic["cccxtwd"]["buy"]) * TWD_USDT
  321. CCXT_TWDT = float(dic["cccxtwdt"]["buy"])* TWDT_USDT
  322. CCXT_MAX = float(dic["cccxmax"]["buy"])* MAX_USDT
  323. CCXT_t_max = {
  324. "cccxusdt" : CCXT_USDT,
  325. "cccxbtc" : CCXT_BTC,
  326. # "cccxeth" : CCXT_ETH,
  327. # "cccxtwd" : CCXT_TWD,
  328. "cccxtwdt" : CCXT_TWDT,
  329. "cccxmax" : CCXT_MAX,
  330. }
  331. maximum = max(CCXT_t_max.values())
  332. maxiCCXT = max(CCXT_t_max, key=CCXT_t_max.get)
  333. CCXT_RES = ( maximum * 100 ) / minimum
  334. if CCXT_RES > 100.7 :
  335. lst.append(CCXT_RES)
  336. def CCXT():
  337. print("")
  338. print("buy from",miniCCXT)
  339. print("sell to",maxiCCXT)
  340. print("")
  341. #--------------------------------------------------------------
  342. # ((( 10 EOS )))
  343. #--------------------------------------------------------------
  344. EOS_USDT = float(dic["eosusdt"]["sell"])
  345. #EOS_BTC = float(dic["eosbtc"]["sell"]) * BTC_USDT
  346. EOS_ETH = float(dic["eoseth"]["sell"]) * ETH_USDT
  347. #EOS_TWD = float(dic["eostwd"]["sell"]) * TWD_USDT
  348. EOS_TWDT = float(dic["eostwdt"]["sell"])* TWDT_USDT
  349. EOS_MAX = float(dic["eosmax"]["sell"])* MAX_USDT
  350. EOS_t_min = {
  351. "eosusdt" : EOS_USDT,
  352. # "eosbtc" : EOS_BTC,
  353. "eoseth" : EOS_ETH,
  354. # "eostwd" : EOS_TWD,
  355. "eostwdt" : EOS_TWDT,
  356. "eosmax" : EOS_MAX,
  357. }
  358. miniEOS = min(EOS_t_min, key=EOS_t_min.get)
  359. minimum = min(EOS_t_min.values())
  360. EOS_USDT = float(dic["eosusdt"]["buy"])
  361. #EOS_BTC = float(dic["eosbtc"]["buy"]) * BTC_USDT
  362. EOS_ETH = float(dic["eoseth"]["buy"]) * ETH_USDT
  363. #EOS_TWD = float(dic["eostwd"]["buy"]) * TWD_USDT
  364. EOS_TWDT = float(dic["eostwdt"]["buy"])* TWDT_USDT
  365. EOS_MAX = float(dic["eosmax"]["buy"])* MAX_USDT
  366. EOS_t_max = {
  367. "eosusdt" : EOS_USDT,
  368. # "eosbtc" : EOS_BTC,
  369. "eoseth" : EOS_ETH,
  370. # "eostwd" : EOS_TWD,
  371. "eostwdt" : EOS_TWDT,
  372. "eosmax" : EOS_MAX,
  373. }
  374. maximum = max(EOS_t_max.values())
  375. maxiEOS = max(EOS_t_max, key=EOS_t_max.get)
  376. EOS_RES = ( maximum * 100 ) / minimum
  377. if EOS_RES > 100.7 :
  378. lst.append(EOS_RES)
  379. def EOS():
  380. print("")
  381. print("buy from",miniEOS)
  382. print("sell to",maxiEOS)
  383. print("")
  384. #--------------------------------------------------------------
  385. # ((( 11 PAL )))
  386. #--------------------------------------------------------------
  387. #PAL_BTC = float(dic["palbtc"]["sell"]) * BTC_USDT
  388. PAL_ETH = float(dic["paleth"]["sell"]) * ETH_USDT
  389. #PAL_TWD = float(dic["paltwd"]["sell"]) * TWD_USDT
  390. PAL_TWDT = float(dic["paltwdt"]["sell"])* TWDT_USDT
  391. PAL_MAX = float(dic["palmax"]["sell"])* MAX_USDT
  392. PAL_t_min = {
  393. # "palbtc" : PAL_BTC,
  394. "paleth" : PAL_ETH,
  395. # "paltwd" : PAL_TWD,
  396. "paltwdt" : PAL_TWDT,
  397. "palmax" : PAL_MAX,
  398. }
  399. miniPAL = min(PAL_t_min, key=PAL_t_min.get)
  400. minimum = min(PAL_t_min.values())
  401. #PAL_BTC = float(dic["palbtc"]["sell"]) * BTC_USDT
  402. PAL_ETH = float(dic["paleth"]["buy"]) * ETH_USDT
  403. #PAL_TWD = float(dic["paltwd"]["buy"]) * TWD_USDT
  404. PAL_TWDT = float(dic["paltwdt"]["buy"])* TWDT_USDT
  405. PAL_MAX = float(dic["palmax"]["buy"])* MAX_USDT
  406. PAL_t_max = {
  407. # "palbtc" : PAL_BTC,
  408. "paleth" : PAL_ETH,
  409. # "paltwd" : PAL_TWD,
  410. "paltwdt" : PAL_TWDT,
  411. "palmax" : PAL_MAX,
  412. }
  413. maximum = max(PAL_t_max.values())
  414. maxiPAL = max(PAL_t_max, key=PAL_t_max.get)
  415. PAL_RES = ( maximum * 100 ) / minimum
  416. if PAL_RES > 100.7 :
  417. lst.append(PAL_RES)
  418. def PAL():
  419. print("")
  420. print("buy from",miniPAL)
  421. print("sell to",maxiPAL)
  422. print("")
  423. #--------------------------------------------------------------
  424. # ((( 12 BAT )))
  425. #--------------------------------------------------------------
  426. #BAT_USDT = float(dic["batusdt"]["sell"])
  427. #BAT_BTC = float(dic["batbtc"]["sell"]) * BTC_USDT
  428. BAT_ETH = float(dic["bateth"]["sell"]) * ETH_USDT
  429. #BAT_TWD = float(dic["battwd"]["sell"]) * TWD_USDT
  430. BAT_TWDT = float(dic["battwdt"]["sell"])* TWDT_USDT
  431. BAT_MAX = float(dic["batmax"]["sell"])* MAX_USDT
  432. BAT_t_min = {
  433. # "batusdt" : BAT_USDT,
  434. # "batbtc" : BAT_BTC,
  435. "bateth" : BAT_ETH,
  436. # "battwd" : BAT_TWD,
  437. "battwdt" : BAT_TWDT,
  438. "batmax" : BAT_MAX,
  439. }
  440. miniBAT = min(BAT_t_min, key=BAT_t_min.get)
  441. minimum = min(BAT_t_min.values())
  442. #BAT_USDT = float(dic["batusdt"]["buy"])
  443. #BAT_BTC = float(dic["batbtc"]["buy"]) * BTC_USDT
  444. BAT_ETH = float(dic["bateth"]["buy"]) * ETH_USDT
  445. #BAT_TWD = float(dic["battwd"]["buy"]) * TWD_USDT
  446. BAT_TWDT = float(dic["battwdt"]["buy"])* TWDT_USDT
  447. BAT_MAX = float(dic["batmax"]["buy"])* MAX_USDT
  448. BAT_t_max = {
  449. # "batusdt" : BAT_USDT,
  450. # "batbtc" : BAT_BTC,
  451. "bateth" : BAT_ETH,
  452. # "battwd" : BAT_TWD,
  453. "battwdt" : BAT_TWDT,
  454. "batmax" : BAT_MAX,
  455. }
  456. maximum = max(BAT_t_max.values())
  457. maxiBAT = max(BAT_t_max, key=BAT_t_max.get)
  458. BAT_RES = ( maximum * 100 ) / minimum
  459. if BAT_RES > 100.7 :
  460. lst.append(BAT_RES)
  461. def BAT():
  462. print("")
  463. print("buy from",miniBAT)
  464. print("sell to",maxiBAT)
  465. print("")
  466. #--------------------------------------------------------------
  467. # ((( 13 ZRX )))
  468. #--------------------------------------------------------------
  469. ZRX_USDT = float(dic["zrxusdt"]["sell"])
  470. ZRX_BTC = float(dic["zrxbtc"]["sell"]) * BTC_USDT
  471. ZRX_ETH = float(dic["zrxeth"]["sell"]) * ETH_USDT
  472. #ZRX_TWD = float(dic["zrxtwd"]["sell"]) * TWD_USDT
  473. ZRX_TWDT = float(dic["zrxtwdt"]["sell"])* TWDT_USDT
  474. ZRX_MAX = float(dic["zrxmax"]["sell"])* MAX_USDT
  475. ZRX_t_min = {
  476. "zrxusdt" : ZRX_USDT,
  477. "zrxbtc" : ZRX_BTC,
  478. "zrxeth" : ZRX_ETH,
  479. # "zrxtwd" : ZRX_TWD,
  480. "zrxtwdt" : ZRX_TWDT,
  481. "zrxmax" : ZRX_MAX,
  482. }
  483. miniZRX = min(ZRX_t_min, key=ZRX_t_min.get)
  484. minimum = min(ZRX_t_min.values())
  485. ZRX_USDT = float(dic["zrxusdt"]["buy"])
  486. ZRX_BTC = float(dic["zrxbtc"]["buy"]) * BTC_USDT
  487. ZRX_ETH = float(dic["zrxeth"]["buy"]) * ETH_USDT
  488. #ZRX_TWD = float(dic["zrxtwd"]["buy"]) * TWD_USDT
  489. ZRX_TWDT = float(dic["zrxtwdt"]["buy"])* TWDT_USDT
  490. ZRX_MAX = float(dic["zrxmax"]["buy"])* MAX_USDT
  491. ZRX_t_max = {
  492. "zrxusdt" : ZRX_USDT,
  493. "zrxbtc" : ZRX_BTC,
  494. "zrxeth" : ZRX_ETH,
  495. # "zrxtwd" : ZRX_TWD,
  496. "zrxtwdt" : ZRX_TWDT,
  497. "zrxmax" : ZRX_MAX,
  498. }
  499. maximum = max(ZRX_t_max.values())
  500. maxiZRX = max(ZRX_t_max, key=ZRX_t_max.get)
  501. ZRX_RES = ( maximum * 100 ) / minimum
  502. if ZRX_RES > 100.7 :
  503. lst.append(ZRX_RES)
  504. def ZRX():
  505. print("")
  506. print("buy from",miniZRX)
  507. print("sell to",maxiZRX)
  508. print("")
  509. #--------------------------------------------------------------
  510. # ((( 14 GNT )))
  511. #--------------------------------------------------------------
  512. #GNT_USDT = float(dic["gntusdt"]["sell"])
  513. #GNT_BTC = float(dic["gntbtc"]["sell"]) * BTC_USDT
  514. #GNT_ETH = float(dic["gnteth"]["sell"]) * ETH_USDT
  515. #GNT_TWD = float(dic["gnttwd"]["sell"]) * TWD_USDT
  516. GNT_TWDT = float(dic["gnttwdt"]["sell"])* TWDT_USDT
  517. GNT_MAX = float(dic["gntmax"]["sell"])* MAX_USDT
  518. GNT_t_min = {
  519. # "gntusdt" : GNT_USDT,
  520. # "gntbtc" : GNT_BTC,
  521. # "gnteth" : GNT_ETH,
  522. # "gnttwd" : GNT_TWD,
  523. "gnttwdt" : GNT_TWDT,
  524. "gntmax" : GNT_MAX,
  525. }
  526. miniGNT = min(GNT_t_min, key=GNT_t_min.get)
  527. minimum = min(GNT_t_min.values())
  528. #GNT_USDT = float(dic["gntusdt"]["buy"])
  529. #GNT_BTC = float(dic["gntbtc"]["buy"]) * BTC_USDT
  530. #GNT_ETH = float(dic["gnteth"]["buy"]) * ETH_USDT
  531. #GNT_TWD = float(dic["gnttwd"]["buy"]) * TWD_USDT
  532. GNT_TWDT = float(dic["gnttwdt"]["buy"])* TWDT_USDT
  533. GNT_MAX = float(dic["gntmax"]["buy"])* MAX_USDT
  534. GNT_t_max = {
  535. # "gntusdt" : GNT_USDT,
  536. # "gntbtc" : GNT_BTC,
  537. # "gnteth" : GNT_ETH,
  538. # "gnttwd" : GNT_TWD,
  539. "gnttwdt" : GNT_TWDT,
  540. "gntmax" : GNT_MAX,
  541. }
  542. maximum = max(GNT_t_max.values())
  543. maxiGNT = max(GNT_t_max, key=GNT_t_max.get)
  544. GNT_RES = ( maximum * 100 ) / minimum
  545. if GNT_RES > 100.7 :
  546. lst.append(GNT_RES)
  547. def GNT():
  548. print("")
  549. print("buy from",miniGNT)
  550. print("sell to",maxiGNT)
  551. print("")
  552. #--------------------------------------------------------------
  553. # ((( 14 OMG )))
  554. #--------------------------------------------------------------
  555. OMG_USDT = float(dic["omgusdt"]["sell"])
  556. OMG_BTC = float(dic["omgbtc"]["sell"]) * BTC_USDT
  557. OMG_ETH = float(dic["omgeth"]["sell"]) * ETH_USDT
  558. #OMG_TWD = float(dic["omgtwd"]["sell"]) * TWD_USDT
  559. OMG_TWDT = float(dic["omgtwdt"]["sell"])* TWDT_USDT
  560. OMG_MAX = float(dic["omgmax"]["sell"])* MAX_USDT
  561. OMG_t_min = {
  562. "omgusdt" : OMG_USDT,
  563. "omgbtc" : OMG_BTC,
  564. "omgeth" : OMG_ETH,
  565. # "omgtwd" : OMG_TWD,
  566. "omgtwdt" : OMG_TWDT,
  567. "omgmax" : OMG_MAX,
  568. }
  569. miniOMG = min(OMG_t_min, key=OMG_t_min.get)
  570. minimum = min(OMG_t_min.values())
  571. OMG_USDT = float(dic["omgusdt"]["buy"])
  572. OMG_BTC = float(dic["omgbtc"]["buy"]) * BTC_USDT
  573. OMG_ETH = float(dic["omgeth"]["buy"]) * ETH_USDT
  574. #OMG_TWD = float(dic["omgtwd"]["buy"]) * TWD_USDT
  575. OMG_TWDT = float(dic["omgtwdt"]["buy"])* TWDT_USDT
  576. OMG_MAX = float(dic["omgmax"]["buy"])* MAX_USDT
  577. OMG_t_max = {
  578. "omgusdt" : OMG_USDT,
  579. "omgbtc" : OMG_BTC,
  580. "omgeth" : OMG_ETH,
  581. # "omgtwd" : OMG_TWD,
  582. "omgtwdt" : OMG_TWDT,
  583. "omgmax" : OMG_MAX,
  584. }
  585. maximum = max(OMG_t_max.values())
  586. maxiOMG = max(OMG_t_max, key=OMG_t_max.get)
  587. OMG_RES = ( maximum * 100 ) / minimum
  588. if OMG_RES > 100.7 :
  589. lst.append(OMG_RES)
  590. def OMG():
  591. print("")
  592. print("buy from",miniOMG)
  593. print("sell to",maxiOMG)
  594. print("")
  595. #--------------------------------------------------------------
  596. # ((( 14 KNC )))
  597. #--------------------------------------------------------------
  598. #KNC_USDT = float(dic["kncusdt"]["sell"])
  599. #KNC_BTC = float(dic["kncbtc"]["sell"]) * BTC_USDT
  600. #KNC_ETH = float(dic["knceth"]["sell"]) * ETH_USDT
  601. #KNC_TWD = float(dic["knctwd"]["sell"]) * TWD_USDT
  602. KNC_TWDT = float(dic["knctwdt"]["sell"])* TWDT_USDT
  603. KNC_MAX = float(dic["kncmax"]["sell"])* MAX_USDT
  604. KNC_t_min = {
  605. # "kncusdt" : KNC_USDT,
  606. # "kncbtc" : KNC_BTC,
  607. # "knceth" : KNC_ETH,
  608. # "knctwd" : KNC_TWD,
  609. "knctwdt" : KNC_TWDT,
  610. "kncmax" : KNC_MAX,
  611. }
  612. miniKNC = min(KNC_t_min, key=KNC_t_min.get)
  613. minimum = min(KNC_t_min.values())
  614. #KNC_USDT = float(dic["kncusdt"]["buy"])
  615. #KNC_BTC = float(dic["kncbtc"]["buy"]) * BTC_USDT
  616. #KNC_ETH = float(dic["knceth"]["buy"]) * ETH_USDT
  617. #KNC_TWD = float(dic["knctwd"]["buy"]) * TWD_USDT
  618. KNC_TWDT = float(dic["knctwdt"]["buy"])* TWDT_USDT
  619. KNC_MAX = float(dic["kncmax"]["buy"])* MAX_USDT
  620. KNC_t_max = {
  621. # "kncusdt" : KNC_USDT,
  622. # "kncbtc" : KNC_BTC,
  623. # "knceth" : KNC_ETH,
  624. # "knctwd" : KNC_TWD,
  625. "knctwdt" : KNC_TWDT,
  626. "kncmax" : KNC_MAX,
  627. }
  628. maximum = max(KNC_t_max.values())
  629. maxiKNC = max(KNC_t_max, key=KNC_t_max.get)
  630. KNC_RES = ( maximum * 100 ) / minimum
  631. if KNC_RES > 100.7 :
  632. lst.append(KNC_RES)
  633. def KNC():
  634. print("")
  635. print("buy from",miniKNC)
  636. print("sell to",maxiKNC)
  637. print("")
  638.  
  639. #------------------------------------------------
  640. #-----------------------------------> output
  641. #------------------------------------------------
  642. res = max(lst)
  643. print("")
  644. print("the profit is:",res)
  645. if res == BTC_RES :
  646. BTC()
  647. if res == LTC_RES :
  648. LTC()
  649. if res == BCH_RES :
  650. BCH()
  651. if res == ETH_RES :
  652. ETH()
  653. if res == MITH_RES :
  654. MITH()
  655. if res == MAX_RES :
  656. MAX()
  657. if res == XRP_RES :
  658. XRP()
  659. if res == TRX_RES :
  660. TRX()
  661. if res == CCXT_RES :
  662. CCXT()
  663. if res == EOS_RES :
  664. EOS()
  665. if res == PAL_RES :
  666. PAL()
  667. if res == BAT_RES :
  668. BAT()
  669. if res == ZRX_RES :
  670. ZRX()
  671. if res == GNT_RES :
  672. GNT()
  673. if res == OMG_RES :
  674. OMG()
  675. if res == KNC_RES :
  676. KNC()
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!