def connect(self): while True: try: self.api.close() except: pass #logging.error('**warning** self.api.close() fail') if self.connect_count < self.max_reconnect or self.max_reconnect < 0: self.api = IQOptionAPI("iqoption.com", self.email, self.password) check = None self.api.set_active_account_type(self.active_account_type) check = self.api.connect() if check == True: while self.api.profile.balance_id == None: pass # -------------reconnect subscribe_candle try: for ac in self.subscribe_candle: sp = ac.split(",") self.start_candles_one_stream(sp[0], sp[1]) except: pass # ----------------- try: for ac in self.subscribe_candle_all_size: self.start_candles_all_size_stream(ac) except: pass # -------------reconnect subscribe_mood try: for ac in self.subscribe_mood: self.start_mood_stream(ac) except: pass #---------for async get name: "position-changed", microserviceName self.api.setOptions(1, True) self.api.subscribe_position_changed( "position-changed", "multi-option", 2) self.api.subscribe_position_changed( "trading-fx-option.position-changed", "fx-option", 3) self.api.subscribe_position_changed( "position-changed", "crypto", 4) self.api.subscribe_position_changed( "position-changed", "forex", 5) self.api.subscribe_position_changed( "digital-options.position-changed", "digital-option", 6) self.api.subscribe_position_changed( "position-changed", "cfd", 7) break time.sleep(self.suspend * 2) self.connect_count = self.connect_count + 1 else: logging.error( '**error** reconnect() too many time please look log file') exit(1)
def __init__(self, config): """ :param config: The instance of :class:`Settings <iqoptionpy.settings.settigns.Settings>`. """ self.config = config self.api = IQOptionAPI(self.config.get_connection_hostname(), self.config.get_connection_username(), self.config.get_connection_password())
def connect(self): while True: try: self.api = IQOptionAPI("iqoption.com", self.email, self.password) self.api.connect() time.sleep(self.suspend) break except: logging.error('**error** connect()') pass
def __init__(self, user=userdata.mainUser, active_id="EURUSD"): self.username = user['username'] self.password = user['password'] self.real = user['real'] self.demo = user['demo'] self.active_id = active_id self.api = IQOptionAPI("iqoption.com", self.username, self.password) self.api.connect() self.setExpirationTime() self.setActives(self.active_id) self.api.changebalance(self.demo)
class Starter(object): """Calss for IQ Option API starter.""" def __init__(self, config): """ :param config: The instance of :class:`Settings <iqoptionpy.settings.settigns.Settings>`. """ self.config = config self.api = IQOptionAPI( self.config.get_connection_hostname(), self.config.get_connection_username(), self.config.get_connection_password() ) def create_connection(self): """Method for create connection to IQ Option API.""" logger = logging.getLogger(__name__) logger.info("Create connection.") self.api.connect() logger.info("Successfully connected.") def start_signalers(self, actives): """Method for start signalers.""" logger = logging.getLogger(__name__) logger.info("Create signalers.") signalers = [] actives = self.config.get_trade_actives() patterns = self.config.get_trade_patterns() for active in actives: signaler = create_signaler(self.api, active) signaler.set_patterns(patterns) signaler.start() signalers.append(signaler) return signalers def start_traders(self, actives): """Method for start traders.""" logger = logging.getLogger(__name__) logger.info("Create traders.") traders = [] actives = self.config.get_trade_actives() for active in actives: trader = create_trader(self.api, active) trader.start() traders.append(trader) return traders
class Starter(object): """Calss for IQ Option API starter.""" def __init__(self, config): """ :param config: The instance of :class:`Settings <iqoptionpy.settings.settigns.Settings>`. """ self.config = config self.api = IQOptionAPI( self.config.get_connection_hostname(), self.config.get_connection_username(), self.config.get_connection_password() ) def create_connection(self): """Method for create connection to IQ Option API.""" logger = logging.getLogger(__name__) logger.info("Create connection.") self.api.connect() logger.info("Successfully connected.") def start_signalers(self, actives): """Method for start signalers.""" logger = logging.getLogger(__name__) logger.info("Create signalers.") signalers = [] actives = self.config.get_trade_actives() patterns = self.config.get_trade_patterns() for active in actives: signaler = create_signaler(self.api, active) signaler.set_patterns(patterns) signaler.start() signalers.append(signaler) return signalers def start_traders(self, actives): """Method for start traders.""" logger = logging.getLogger(__name__) logger.info("Create traders.") traders = [] actives = self.config.get_trade_actives() for active in actives: trader = create_trader(self.api, active) trader.start() traders.append(trader) return traders
def connect(self): while True: try: try: self.api.close() except: pass #logging.error('**warning** self.api.close() it can ignore') self.api = IQOptionAPI("iqoption.com", self.email, self.password) self.api.connect() time.sleep(self.suspend) break except: logging.error( '**error** connect():DO you install right version?') pass
def __init__(self, threadID, name, value, active, t, op): threading.Thread.__init__(self) self.threadID = threadID self.name = name self.value = value self.active = active self.t = t self.op = op ## put call self.api = IQOptionAPI("iqoption.com", "*****@*****.**", "b418b418")
def connect(self): while True: try: self.api.close() except: pass #logging.error('**warning** self.api.close() fail') if self.connect_count < self.max_reconnect: self.api = IQOptionAPI("iqoption.com", self.email, self.password) check = None try: check = self.api.connect() except: logging.error('**error** connect() fail') if check == True: # -------------reconnect subscribe_candle try: for ac in self.subscribe_candle: sp = ac.split(",") self.start_candles_one_stream(sp[0], sp[1]) except: pass # ----------------- try: for ac in self.subscribe_candle_all_size: self.start_candles_all_size_stream(ac) except: pass # -------------reconnect subscribe_mood try: for ac in self.subscribe_mood: self.start_mood_stream(ac) except: pass break time.sleep(self.suspend * 2) self.connect_count = self.connect_count + 1 else: logging.error( '**error** reconnect() too many time please look log file') exit(1)
def __init__(self, config): """ :param config: The instance of :class:`Settings <iqoptionpy.settings.settigns.Settings>`. """ self.config = config self.api = IQOptionAPI( self.config.get_connection_hostname(), self.config.get_connection_username(), self.config.get_connection_password() )
def conectar(id_activo): velas = None while velas is None: print "Intento de conexión..." api = IQOptionAPI("iqoption.com", "usuario", "contraseña") api.connect() api.getcandles(id_activo, 1) velas = api.candles.candles_data return velas
def conectar(id_activo): for i in range(4): api = IQOptionAPI("iqoption.com", "usuario", "contraseña") api.connect() for j in range(4): api.getcandles(1, 1) time.sleep(0.5) velas = api.candles.candles_data time.sleep(30) return velas
class IQ_Option: def __init__(self, email, password): self.email = email self.password = password self.suspend = 0.5 self.thread = None self.connect() self.thread_collect_realtime = {} self.update_ACTIVES_OPCODE() #time.sleep(self.suspend) #*** def connect(self): while True: try: try: self.api.close() except: pass #logging.error('**warning** self.api.close() it can ignore') self.api = IQOptionAPI("iqoption.com", self.email, self.password) self.api.connect() time.sleep(self.suspend) break except: logging.error( '**error** connect():DO you install right version?') pass #wait for timestamp getting #_________________________UPDATE ACTIVES OPCODE_____________________ def get_all_ACTIVES_OPCODE(self): return OP_code.ACTIVES def update_ACTIVES_OPCODE(self): #update from binary option self.get_ALL_Binary_ACTIVES_OPCODE() #crypto /dorex/cfd self.get_all_instruments() dicc = {} for lis in sorted(OP_code.ACTIVES.items(), key=operator.itemgetter(1)): dicc[lis[0]] = lis[1] OP_code.ACTIVES = dicc def instruments_input(self, types): time.sleep(self.suspend) self.api.instruments = None while self.api.instruments == None: self.api.get_instruments(types) start = time.time() while self.api.instruments == None and time.time() - start < 10: pass for ins in self.api.instruments["instruments"]: OP_code.ACTIVES[ins["id"]] = ins["active_id"] def get_all_instruments(self): self.instruments_input("crypto") self.instruments_input("forex") self.instruments_input("cfd") def get_ALL_Binary_ACTIVES_OPCODE(self): init_info = self.get_all_init() for i in init_info["result"]["binary"]["actives"]: OP_code.ACTIVES[(init_info["result"]["binary"]["actives"][i] ["name"]).split(".")[1]] = int(i) #_________________________self.api.get_api_option_init_all() wss______________________ def get_all_init(self): self.api.api_option_init_all_result = None while True: try: self.api.get_api_option_init_all() start = time.time() while True: if time.time() - start > 30: logging.error('**warning** get_all_init late 30 sec') break try: if self.api.api_option_init_all_result != None: break except: self.api.get_api_option_init_all() time.sleep(self.suspend * 2) if self.api.api_option_init_all_result["isSuccessful"] == True: break except: logging.error('**error** get_all_init need reconnect') self.connect() return self.api.api_option_init_all_result #return OP_code.ACTIVES def get_profit(self, ACTIVES): init_info = self.get_all_init() return (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[ACTIVES])]["option"]["profit"]["commission"] ) / 100.0 def get_all_profit(self): all_profit = {} init_info = self.get_all_init() for active in OP_code.ACTIVES: try: prof = (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[active])]["option"]["profit"]["commission"] ) / 100.0 all_profit[active] = prof except: pass return all_profit #______________________________________self.api.getprofile() https________________________________ def get_profile(self): while True: try: respon = self.api.getprofile().json() time.sleep(self.suspend) if respon["isSuccessful"] == True: return respon except: logging.error('**error** get_profile') def get_balance(self): #self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balance = respon["result"]["balance"] break except: logging.error('**error** get_balance()') pass time.sleep(self.suspend) return self.api.profile.balance def get_balances(self): #self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balances = respon["result"]["balances"] break except: logging.error('**error** get_balances()') pass time.sleep(self.suspend) return self.api.profile.balances def get_balance_mode(self): #self.api.profile.balance_type=None while True: try: respon = self.get_profile() self.api.profile.balance_type = respon["result"][ "balance_type"] break except: logging.error('**error** get_balance_mode()') pass time.sleep(self.suspend) if self.api.profile.balance_type == 1: return "REAL" elif self.api.profile.balance_type == 4: return "PRACTICE" def change_balance(self, Balance_MODE): real_id = None practice_id = None while True: try: self.get_balances() for accunt in self.api.profile.balances: if accunt["type"] == 1: real_id = accunt["id"] if accunt["type"] == 4: practice_id = accunt["id"] break except: logging.error('**error** change_balance()') pass while self.get_balance_mode() != Balance_MODE: if Balance_MODE == "REAL": self.api.changebalance(real_id) elif Balance_MODE == "PRACTICE": self.api.changebalance(practice_id) else: print("ERROR doesn't have this mode") exit(1) #________________________________________________________________________ #_______________________ CANDLE _____________________________ #________________________self.api.getcandles() wss________________________ def get_candles(self, ACTIVES, interval, count, endtime): while True: try: self.api.getcandles(OP_code.ACTIVES[ACTIVES], interval, count, endtime) break except: logging.error('**error** get_candles need reconnect') self.connect() pass while self.api.candles.candles_data == None: pass return self.api.candles.candles_data #______________________________________________________________ #_____________________________REAL TIME CANDLE_________________ #______________________________________________________________ #all need to fixxxxxxxxxxxxxxxxxxxxxxx def start_all_candles_stream(self): while self.api.real_time_candles == {}: for ACTIVES_name in OP_code.ACTIVES: self.api.subscribe(OP_code.ACTIVES[ACTIVES_name]) time.sleep(self.suspend) time.sleep(self.suspend) def get_all_realtime_candles(self): return self.api.real_time_candles def stop_all_candles_stream(self): while self.api.real_time_candles != {}: self.api.real_time_candles = {} time.sleep(self.suspend) for ACTIVES_name in OP_code.ACTIVES: self.api.unsubscribe(OP_code.ACTIVES[ACTIVES_name]) ############################################## ##one def start_candles_stream(self, ACTIVES): try: self.api.subscribe(OP_code.ACTIVES[ACTIVES]) start = time.time() while True: if time.time() - start > 20: logging.error('**error** fail ' + ACTIVES + ' start_candles_stream late for 10 sec') return False try: if self.api.real_time_candles[ACTIVES] != {}: break except: time.sleep(1) self.api.subscribe(OP_code.ACTIVES[ACTIVES]) if self.api.real_time_candles[ACTIVES] != {}: return True except: logging.error('**error** start_candles_stream reconnect') self.connect() def get_realtime_candles(self, ACTIVES): try: return self.api.real_time_candles[ACTIVES] except: logging.error('**error** get_realtime_candles()') return False def stop_candles_stream(self, ACTIVES): while True: try: if self.api.real_time_candles[ACTIVES] == {}: break except: pass self.api.real_time_candles[ACTIVES] = {} time.sleep(1) self.api.unsubscribe(OP_code.ACTIVES[ACTIVES]) #__________________________Collect realtime_____________________________ #______thread_____ def dict_queue_add(self, dict, ACTIVES, maxdict, key, value): while True: if len(dict) <= maxdict: dict[(ACTIVES, key)] = value break else: #del mini key del dict[sorted(dict.keys(), reverse=False)[0]] def thread_realtime(self, ACTIVES, maxdict): t = threading.currentThread() while getattr(t, "do_run", True): candles = self.get_realtime_candles(ACTIVES) self.dict_queue_add(dict=self.thread_collect_realtime, ACTIVES=ACTIVES, maxdict=maxdict, key=candles["at"], value=candles) #self.thread_collect_realtime={} def collect_realtime_candles_thread_start(self, ACTIVES, maxdict): t = threading.Thread(target=self.thread_realtime, args=(ACTIVES, maxdict)) t.start() return t def collect_realtime_candles_thread_stop(self, thread): thread.do_run = False thread.join() # ___None thread___ def collect_realtime_candles(self, ACTIVES, collect_time): #doing while untill time stop collect = {} start = time.time() while time.time() < start + collect_time: candles = self.get_realtime_candles(ACTIVES) collect[candles["at"]] = candles return collect ############################################################################################## def get_candles_as_array(self, ACTIVES, interval, count, endtime): candles = self.get_candles(ACTIVES, interval, count, endtime) ans = np.empty(shape=(len(candles), 4)) for idx, candle in enumerate(candles): ans[idx][0] = candle["open"] ans[idx][1] = candle["close"] ans[idx][2] = candle["min"] ans[idx][3] = candle["max"] return ans def check_win(self, id_number): #'win':win money 'equal':no win no loose 'loose':loose money while True: try: listinfodata_dict = self.api.listinfodata.get(id_number) if listinfodata_dict["game_state"] == 1: break except: pass self.api.listinfodata.delete(id_number) return listinfodata_dict["win"] #__________________________BUY__________________________ #__________________FOR OPTION____________________________ def buy(self, price, ACTIVES, ACTION, expirations, force_buy=True): self.api.buy_successful == None while True: while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], ACTION, expirations) break except: if force_buy == False: return (False, None) logging.error('self.api.buy error') self.connect() pass start = time.time() while self.api.buy_successful == None: if time.time() - start > 60: logging.error('check buy_successful time late 60sec') break if self.api.buy_successful: return (True, self.api.buy_id) else: if force_buy == False: return (False, None) logging.error('**error** buy error...') self.connect()
#!/usr/bin/python # -*- coding: utf-8 -*- from iqoptionapi.api import IQOptionAPI from datetime import datetime from datetime import time as tiempo import time import numpy as np import threading api = IQOptionAPI("iqoption.com", "usuario", "contraseña") api.connect() def conectar(id_activo): velas = None while velas is None: print "Intento de conexión..." api = IQOptionAPI("iqoption.com", "usuario", "contraseña") api.connect() api.getcandles(id_activo, 1) velas = api.candles.candles_data return velas def obtener_velas(id_activo): if id_activo == 1: activo = "EURUSD" else: activo = "EURGBP"
class IQ_Option: __version__ = "2.1.1" def __init__(self, email, password): self.size = [ 1, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200, 14400, 28800, 43200, 86400, 604800, 2592000 ] self.email = email self.password = password self.suspend = 0.5 self.thread = None self.subscribe_candle = [] self.subscribe_candle_all_size = [] self.subscribe_mood = [] #--start self.connect() self.update_ACTIVES_OPCODE() self.get_balance_id() def get_server_time(self): return self.api.timesync.server_timestamp def connect(self): while True: try: self.api.close() except: pass #logging.error('**warning** self.api.close() fail') self.api = IQOptionAPI("iqoption.com", self.email, self.password) check = None try: check = self.api.connect() except: logging.error('**error** connect() fail') if check == True: #-------------reconnect subscribe_candle try: for ac in self.subscribe_candle: sp = ac.split(",") self.start_candles_one_stream(sp[0], sp[1]) except: pass #----------------- try: for ac in self.subscribe_candle_all_size: self.start_candles_all_size_stream(ac) except: pass #-------------reconnect subscribe_mood try: for ac in self.subscribe_mood: self.start_mood_stream(ac) except: pass break time.sleep(self.suspend * 2) def check_connect(self): #True/False return self.api.websocket_alive() #wait for timestamp getting #_________________________UPDATE ACTIVES OPCODE_____________________ def get_all_ACTIVES_OPCODE(self): return OP_code.ACTIVES def update_ACTIVES_OPCODE(self): #update from binary option self.get_ALL_Binary_ACTIVES_OPCODE() #crypto /dorex/cfd self.get_all_instruments() dicc = {} for lis in sorted(OP_code.ACTIVES.items(), key=operator.itemgetter(1)): dicc[lis[0]] = lis[1] OP_code.ACTIVES = dicc def instruments_input(self, types): time.sleep(self.suspend) self.api.instruments = None while self.api.instruments == None: try: self.api.get_instruments(types) start = time.time() while self.api.instruments == None and time.time() - start < 10: pass except: logging.error('**error** api.get_instruments need reconnect') self.connect() for ins in self.api.instruments["instruments"]: OP_code.ACTIVES[ins["id"]] = ins["active_id"] def get_all_instruments(self): self.instruments_input("crypto") self.instruments_input("forex") self.instruments_input("cfd") def get_ALL_Binary_ACTIVES_OPCODE(self): init_info = self.get_all_init() for i in init_info["result"]["binary"]["actives"]: OP_code.ACTIVES[(init_info["result"]["binary"]["actives"][i] ["name"]).split(".")[1]] = int(i) #_________________________self.api.get_api_option_init_all() wss______________________ def get_all_init(self): self.api.api_option_init_all_result = None while True: try: self.api.get_api_option_init_all() start = time.time() while True: if time.time() - start > 30: logging.error('**warning** get_all_init late 30 sec') break try: if self.api.api_option_init_all_result != None: break except: time.sleep(self.suspend * 5) break if self.api.api_option_init_all_result["isSuccessful"] == True: break except: logging.error('**error** get_all_init need reconnect') self.connect() return self.api.api_option_init_all_result #return OP_code.ACTIVES def get_profit(self, ACTIVES): init_info = self.get_all_init() return (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[ACTIVES])]["option"]["profit"]["commission"] ) / 100.0 def get_all_profit(self): all_profit = {} init_info = self.get_all_init() for active in OP_code.ACTIVES: try: prof = (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[active])]["option"]["profit"]["commission"] ) / 100.0 all_profit[active] = prof except: pass return all_profit #______________________________________self.api.getprofile() https________________________________ def get_profile(self): while True: try: respon = self.api.getprofile().json() time.sleep(self.suspend) if respon["isSuccessful"] == True: return respon except: logging.error('**error** get_profile try reconnect') self.connect() def get_balance_id(self): self.api.profile.balance_id = None while True: try: respon = self.get_profile() self.api.profile.balance_id = respon["result"]["balance_id"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balance(self): self.api.profile.balance = None while True: try: respon = self.get_profile() self.api.profile.balance = respon["result"]["balance"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balances(self): #self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balances = respon["result"]["balances"] break except: logging.error('**error** get_balances()') pass time.sleep(self.suspend) return self.api.profile.balances def get_balance_mode(self): #self.api.profile.balance_type=None while True: try: respon = self.get_profile() self.api.profile.balance_type = respon["result"][ "balance_type"] break except: logging.error('**error** get_balance_mode()') pass time.sleep(self.suspend) if self.api.profile.balance_type == 1: return "REAL" elif self.api.profile.balance_type == 4: return "PRACTICE" def change_balance(self, Balance_MODE): real_id = None practice_id = None while True: try: self.get_balances() for accunt in self.api.profile.balances: if accunt["type"] == 1: real_id = accunt["id"] if accunt["type"] == 4: practice_id = accunt["id"] break except: logging.error('**error** change_balance()') pass while self.get_balance_mode() != Balance_MODE: if Balance_MODE == "REAL": self.api.changebalance(real_id) elif Balance_MODE == "PRACTICE": self.api.changebalance(practice_id) else: print("ERROR doesn't have this mode") exit(1) #________________________________________________________________________ #_______________________ CANDLE _____________________________ #________________________self.api.getcandles() wss________________________ def get_candles(self, ACTIVES, interval, count, endtime): self.api.candles.candles_data = None while True: try: self.api.getcandles(OP_code.ACTIVES[ACTIVES], interval, count, endtime) while self.check_connect and self.api.candles.candles_data == None: pass if self.api.candles.candles_data != None: break except: logging.error('**error** get_candles need reconnect') self.connect() return self.api.candles.candles_data ####################################################### #______________________________________________________ #_____________________REAL TIME CANDLE_________________ #______________________________________________________ ####################################################### def start_candles_stream(self, ACTIVE, size, maxdict): if size == "all": for s in self.size: self.full_realtime_get_candle(ACTIVE, s, maxdict) self.api.real_time_candles_maxdict_table[ACTIVE][s] = maxdict self.start_candles_all_size_stream(ACTIVE) elif size in self.size: self.api.real_time_candles_maxdict_table[ACTIVE][size] = maxdict self.full_realtime_get_candle(ACTIVE, size, maxdict) self.start_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def stop_candles_stream(self, ACTIVE, size): if size == "all": self.stop_candles_all_size_stream(ACTIVE) elif size in self.size: self.stop_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def get_realtime_candles(self, ACTIVE, size): if size == "all": try: return self.api.real_time_candles[ACTIVE] except: logging.error( '**error** get_realtime_candles() size="all" can not get candle' ) return False elif size in self.size: try: return self.api.real_time_candles[ACTIVE][size] except: logging.error('**error** get_realtime_candles() size=' + str(size) + ' can not get candle') return False else: logging.error( '**error** get_realtime_candles() please input right "size"') def get_all_realtime_candles(self): return self.api.real_time_candles ################################################ #---------REAL TIME CANDLE Subset Function--------- ################################################ #---------------------full dict get_candle----------------------- def full_realtime_get_candle(self, ACTIVE, size, maxdict): candles = self.get_candles(ACTIVE, size, maxdict, self.api.timesync.server_timestamp) for can in candles: self.api.real_time_candles[str(ACTIVE)][int(size)][ can["from"]] = can #------------------------Subscribe ONE SIZE----------------------- def start_candles_one_stream(self, ACTIVE, size): if (str(ACTIVE + "," + str(size)) in self.subscribe_candle) == False: self.subscribe_candle.append((ACTIVE + "," + str(size))) start = time.time() self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} while True: if time.time() - start > 20: logging.error( '**error** start_candles_one_stream late for 20 sec') return False try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == True: return True except: pass try: self.api.subscribe(OP_code.ACTIVES[ACTIVE], size) except: logging.error('**error** start_candles_stream reconnect') self.connect() time.sleep(1) def stop_candles_one_stream(self, ACTIVE, size): if ((ACTIVE + "," + str(size)) in self.subscribe_candle) == True: self.subscribe_candle.remove(ACTIVE + "," + str(size)) while True: try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == {}: return True except: pass self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} self.api.unsubscribe(OP_code.ACTIVES[ACTIVE], size) time.sleep(self.suspend * 10) #------------------------Subscribe ALL SIZE----------------------- def start_candles_all_size_stream(self, ACTIVE): self.api.candle_generated_all_size_check[str(ACTIVE)] = {} if (str(ACTIVE) in self.subscribe_candle_all_size) == False: self.subscribe_candle_all_size.append(str(ACTIVE)) start = time.time() while True: if time.time() - start > 20: logging.error('**error** fail ' + ACTIVE + ' start_candles_all_size_stream late for 10 sec') return False try: if self.api.candle_generated_all_size_check[str( ACTIVE)] == True: return True except: pass try: self.api.subscribe_all_size(OP_code.ACTIVES[ACTIVE]) except: logging.error( '**error** start_candles_all_size_stream reconnect') self.connect() time.sleep(1) def stop_candles_all_size_stream(self, ACTIVE): if (str(ACTIVE) in self.subscribe_candle_all_size) == True: self.subscribe_candle_all_size.remove(str(ACTIVE)) while True: try: if self.api.candle_generated_all_size_check[str(ACTIVE)] == {}: break except: pass self.api.candle_generated_all_size_check[str(ACTIVE)] = {} self.api.unsubscribe_all_size(OP_code.ACTIVES[ACTIVE]) time.sleep(self.suspend * 10) #--------------------------------------------------------------------- ################################################ ################################################ #----------------------------------------------- #-----------------traders_mood---------------------- def start_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == False: self.subscribe_mood.append(ACTIVES) while True: self.api.subscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) try: self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] break except: time.sleep(1) def stop_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == True: del self.subscribe_mood[ACTIVES] self.api.unsubscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) def get_traders_mood(self, ACTIVES): #return highter % return self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] def get_all_traders_mood(self): #return highter % return self.api.traders_mood ############################################################################################## def check_win(self, id_number): #'win':win money 'equal':no win no loose 'loose':loose money while True: try: listinfodata_dict = self.api.listinfodata.get(id_number) if listinfodata_dict["game_state"] == 1: break except: pass self.api.listinfodata.delete(id_number) return listinfodata_dict["win"] def check_win_v2(self, id_number): while True: check, data = self.get_betinfo(id_number) if check: return data[str(id_number)]["win"] time.sleep(self.suspend) def get_betinfo(self, id_number): #INPUT:int while True: self.api.game_betinfo.isSuccessful = None start = time.time() try: self.api.get_betinfo(id_number) except: logging.error( '**error** def get_betinfo self.api.get_betinfo reconnect' ) self.connect() while self.api.game_betinfo.isSuccessful == None: if time.time() - start > 10: logging.error( '**error** get_betinfo time out need reconnect') self.connect() self.api.get_betinfo(id_number) time.sleep(self.suspend * 10) if self.api.game_betinfo.isSuccessful == True: return self.api.game_betinfo.isSuccessful, self.api.game_betinfo.dict else: return self.api.game_betinfo.isSuccessful, None time.sleep(self.suspend * 10) #__________________________BUY__________________________ #__________________FOR OPTION____________________________ def buy(self, price, ACTIVES, ACTION, expirations, force_buy=True): self.api.buy_successful == None while True: while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], ACTION, expirations) break except: if force_buy == False: return (False, None) logging.error('self.api.buy error') self.connect() pass start = time.time() while self.api.buy_successful == None: if time.time() - start > 60: logging.error('check buy_successful time late 60sec') break if self.api.buy_successful: return (True, self.api.buy_id) else: if force_buy == False: return (False, None) logging.error('**error** buy error...') self.connect() #__________________for digit_____________ def get_strike_list_data(self, ACTIVES, expirations): try: self.api.strike_list.del_data(ACTIVES, expirations) except: pass while True: self.api.get_strike_list(ACTIVES, expirations) all_strike_list_data = self.api.strike_list.get_All_data() try: return all_strike_list_data[str(ACTIVES), str(expirations)] except: pass time.sleep(self.suspend * 3) def buy_digit(self, price, direction, instrument_id): self.api.digit_buy(price, direction, instrument_id) #---------------------------------------------------------- #-----------------BUY_for__Forex__&&__stock(cfd)__&&__ctrpto def buy_order(self, instrument_type, instrument_id, side, type, amount, limit_price, leverage, stop_lose_price, take_profit_price): self.api.buy_order_id = None self.api.buy_order(instrument_type=instrument_type, instrument_id=instrument_id, side=side, type=type, amount=amount, limit_price=limit_price, stop_price=0, leverage=leverage, stop_lose_price=stop_lose_price, take_profit_price=take_profit_price) while self.api.buy_order_id == None: pass check, data = self.get_order(self.api.buy_order_id) while data["status"] == "pending_new": check, data = self.get_order(self.api.buy_order_id) time.sleep(1) if check: if data["status"] != "rejected": return True, self.api.buy_order_id else: return False, None else: return False, None def get_order(self, buy_order_id): #self.api.order_data["status"] #reject:you can not get this order #pending_new:this order is working now #filled:this order is ok now #new self.api.order_data = None self.api.get_order(buy_order_id) while self.api.order_data == None: pass if self.api.order_data["status"] == 2000: return True, self.api.order_data["msg"] else: return False, None #this function is heavy def get_positions(self, instrument_type): self.api.positions = None self.api.get_positions(instrument_type) while self.api.positions == None: pass if self.api.positions["status"] == 2000: return True, self.api.positions["msg"] else: return False, None #this function is heavy def get_position_history(self, instrument_type): self.api.position_history = None self.api.get_position_history(instrument_type) while self.api.position_history == None: pass if self.api.position_history["status"] == 2000: return True, self.api.position_history["msg"] else: return False, None def get_available_leverages(self, instrument_type, actives): self.api.available_leverages = None self.api.get_available_leverages(instrument_type, OP_code.ACTIVES[actives]) while self.api.available_leverages == None: pass if self.api.available_leverages["status"] == 2000: return True, self.api.available_leverages["msg"] else: return False, None def cancel_order(self, buy_order_id): self.api.order_canceled = None self.api.cancel_order(buy_order_id) while self.api.order_canceled == None: pass if self.api.order_canceled["status"] == 2000: return True else: return False def close_position(self, buy_order_id): check, data = self.get_order(buy_order_id) if data["position_id"] != None: self.api.close_position_data = None self.api.close_position(data["position_id"]) while self.api.close_position_data == None: pass if self.api.close_position_data["status"] == 2000: return True else: return False else: return False def get_overnight_fee(self, instrument_type, active): self.api.overnight_fee = None self.api.get_overnight_fee(instrument_type, OP_code.ACTIVES[active]) while self.api.overnight_fee == None: pass if self.api.overnight_fee["status"] == 2000: return True, self.api.overnight_fee["msg"] else: return False, None
class IQ_Option: def __init__(self, email, password): self.email = email self.password = password self.suspend = 0.5 self.connect() self.thread_collect_realtime = {} #*** def connect(self): while True: try: self.api = IQOptionAPI("iqoption.com", self.email, self.password) self.api.connect() time.sleep(self.suspend) break except: logging.error('**error** connect()') pass ################################################################################## def get_all_init(self): self.api.api_option_init_all_result = None while True: try: self.api.get_api_option_init_all() time.sleep(self.suspend) try: if self.api.api_option_init_all_result[ "isSuccessful"] == True: break except: pass except: logging.error('**error** get_all_init need reconnect') self.connect() return self.api.api_option_init_all_result def get_ALL_Binary_ACTIVES_OPCODE(self): init_info = self.get_all_init() for i in init_info["result"]["binary"]["actives"]: OP_code.ACTIVES[(init_info["result"]["binary"]["actives"][i] ["name"]).split(".")[1]] = i return OP_code.ACTIVES def get_profit(self, ACTIVES): init_info = self.get_all_init() return (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[ACTIVES])]["option"]["profit"]["commission"] ) / 100.0 def get_all_profit(self): all_profit = {} init_info = self.get_all_init() for active in OP_code.ACTIVES: try: prof = (100.0 - init_info["result"]["turbo"]["actives"][str( OP_code.ACTIVES[active])]["option"]["profit"]["commission"] ) / 100.0 all_profit[active] = prof except: pass return all_profit ################################################################################################## def get_profile(self): while True: try: respon = self.api.getprofile().json() time.sleep(self.suspend) if respon["isSuccessful"] == True: return respon except: logging.error('**error** get_profile') #------------------------https profile------------------------ def get_balance(self): #self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balance = respon["result"]["balance"] break except: logging.error('**error** get_balance()') pass time.sleep(self.suspend) return self.api.profile.balance def get_balances(self): #self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balances = respon["result"]["balances"] break except: logging.error('**error** get_balances()') pass time.sleep(self.suspend) return self.api.profile.balances def get_balance_mode(self): #self.api.profile.balance_type=None while True: try: respon = self.get_profile() self.api.profile.balance_type = respon["result"][ "balance_type"] break except: logging.error('**error** get_balance_mode()') pass time.sleep(self.suspend) if self.api.profile.balance_type == 1: return "REAL" elif self.api.profile.balance_type == 4: return "PRACTICE" #------------------------------------------------ def change_balance(self, Balance_MODE): real_id = None practice_id = None while True: try: self.get_balances() for accunt in self.api.profile.balances: if accunt["type"] == 1: real_id = accunt["id"] if accunt["type"] == 4: practice_id = accunt["id"] break except: logging.error('**error** change_balance()') pass while self.get_balance_mode() != Balance_MODE: if Balance_MODE == "REAL": self.api.changebalance(real_id) elif Balance_MODE == "PRACTICE": self.api.changebalance(practice_id) else: print("ERROR doesn't have this mode") exit(1) #######################**********candles***********####################### def get_candles(self, ACTIVES, interval, count, endtime): while True: try: self.api.getcandles(OP_code.ACTIVES[ACTIVES], interval, count, endtime) break except: logging.error('**error** get_candles need reconnect') self.connect() pass while self.api.candles.candles_data == None: pass return self.api.candles.candles_data ################################################################################ ################### real time ########################### ################################################################################ #all def start_all_candles_stream(self): while self.api.real_time_candles == {}: for ACTIVES_name in OP_code.ACTIVES: self.api.subscribe(OP_code.ACTIVES[ACTIVES_name]) time.sleep(self.suspend) def get_all_realtime_candles(self): return self.api.real_time_candles def stop_all_candles_stream(self): while self.api.real_time_candles != {}: self.api.real_time_candles = {} time.sleep(self.suspend) for ACTIVES_name in OP_code.ACTIVES: self.api.unsubscribe(OP_code.ACTIVES[ACTIVES_name]) ##one def start_candles_stream(self, ACTIVES): while self.api.real_time_candles == {}: time.sleep(self.suspend) self.api.subscribe(OP_code.ACTIVES[ACTIVES]) def get_realtime_candles(self, ACTIVES): while True: try: return self.api.real_time_candles[ACTIVES] except: logging.error('**error** get_realtime_candles()') pass def stop_candles_stream(self, ACTIVES): while self.api.real_time_candles != {}: self.api.real_time_candles = {} time.sleep(self.suspend) self.api.unsubscribe(OP_code.ACTIVES[ACTIVES]) ###################################collect realtime################################### #####dict controler#### def dict_queue_add(self, dict, ACTIVES, maxdict, key, value): while True: if len(dict) <= maxdict: dict[(ACTIVES, key)] = value break else: #del mini key del dict[sorted(dict.keys(), reverse=False)[0]] def thread_realtime(self, ACTIVES, maxdict): t = threading.currentThread() while getattr(t, "do_run", True): candles = self.get_realtime_candles(ACTIVES) self.dict_queue_add(dict=self.thread_collect_realtime, ACTIVES=ACTIVES, maxdict=maxdict, key=candles["at"], value=candles) #self.thread_collect_realtime={} def collect_realtime_candles_thread_start(self, ACTIVES, maxdict): t = threading.Thread(target=self.thread_realtime, args=(ACTIVES, maxdict)) t.start() return t def collect_realtime_candles_thread_stop(self, thread): thread.do_run = False thread.join() def collect_realtime_candles(self, ACTIVES, collect_time): #doing while untill time stop collect = {} start = time.time() while time.time() < start + collect_time: candles = self.get_realtime_candles(ACTIVES) collect[candles["at"]] = candles return collect ############################################################################################## def get_candles_as_array(self, ACTIVES, interval, count, endtime): candles = self.get_candles(ACTIVES, interval, count, endtime) ans = np.empty(shape=(len(candles), 4)) for idx, candle in enumerate(candles): ans[idx][0] = candle["open"] ans[idx][1] = candle["close"] ans[idx][2] = candle["min"] ans[idx][3] = candle["max"] return ans def check_win(self): #'win':win money 'equal':no win no loose 'loose':loose money self.api.listinfodata.__init__() start = time.time() while True: try: state = self.api.listinfodata.current_listinfodata.game_state if state == 1: break except: if time.time() - start > 180: logging.error('check_win time late 120sec') return self.api.listinfodata.current_listinfodata.win def buy(self, price, ACTIVES, ACTION): self.api.buy_successful == None while True: while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], "turbo", ACTION) break except: logging.error('self.api.buy error') pass start = time.time() while self.api.buy_successful == None: if time.time() - start > 60: logging.error('check buy_successful time late 60sec') break if self.api.buy_successful: break else: logging.error('**error** buy need reconnect') self.connect() #print("buy ok") def call(self, price, ACTIVES): while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], "turbo", "call") except: pass def put(self, price, ACTIVES): while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], "turbo", "put") except: pass
class IQ_Option: __version__ = "4.5" def __init__(self, email, password): self.size = [ 1, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200, 14400, 28800, 43200, 86400, 604800, 2592000 ] self.email = email self.password = password self.suspend = 0.5 self.thread = None self.subscribe_candle = [] self.subscribe_candle_all_size = [] self.subscribe_mood = [] # for digit self.get_realtime_strike_list_temp_data = {} self.get_realtime_strike_list_temp_expiration = 0 # self.max_reconnect = 5 self.connect_count = 0 # --start self.connect() # self.update_ACTIVES_OPCODE() this auto function delay too long self.get_balance_id() # -------------------------------------------------------------------------- def get_server_timestamp(self): return self.api.timesync.server_timestamp def set_max_reconnect(self, number): self.max_reconnect = number def connect(self): while True: try: self.api.close() except: pass #logging.error('**warning** self.api.close() fail') if self.connect_count < self.max_reconnect or self.max_reconnect < 0: self.api = IQOptionAPI("iqoption.com", self.email, self.password) check = None check = self.api.connect() if check == True: # -------------reconnect subscribe_candle try: for ac in self.subscribe_candle: sp = ac.split(",") self.start_candles_one_stream(sp[0], sp[1]) except: pass # ----------------- try: for ac in self.subscribe_candle_all_size: self.start_candles_all_size_stream(ac) except: pass # -------------reconnect subscribe_mood try: for ac in self.subscribe_mood: self.start_mood_stream(ac) except: pass #---------for async get name: "position-changed", microserviceName self.api.setOptions(1, True) self.api.subscribe_position_changed( "position-changed", "multi-option", 2) self.api.subscribe_position_changed( "trading-fx-option.position-changed", "fx-option", 3) self.api.subscribe_position_changed( "position-changed", "crypto", 4) self.api.subscribe_position_changed( "position-changed", "forex", 5) self.api.subscribe_position_changed( "digital-options.position-changed", "digital-option", 6) self.api.subscribe_position_changed( "position-changed", "cfd", 7) break time.sleep(self.suspend * 2) self.connect_count = self.connect_count + 1 else: logging.error( '**error** reconnect() too many time please look log file') exit(1) def check_connect(self): # True/False idle_time = abs(self.api.timesync.server_timestamp - time.time()) if idle_time > 6: return False else: return True # wait for timestamp getting # _________________________UPDATE ACTIVES OPCODE_____________________ def get_all_ACTIVES_OPCODE(self): return OP_code.ACTIVES def update_ACTIVES_OPCODE(self): # update from binary option self.get_ALL_Binary_ACTIVES_OPCODE() #crypto /dorex/cfd self.instruments_input_all_in_ACTIVES() dicc = {} for lis in sorted(OP_code.ACTIVES.items(), key=operator.itemgetter(1)): dicc[lis[0]] = lis[1] OP_code.ACTIVES = dicc def get_name_by_activeId(self, activeId): info = self.get_financial_information(activeId) try: return info["msg"]["data"]["active"]["name"] except: return None def get_financial_information(self, activeId): self.api.financial_information = None self.api.get_financial_information(activeId) while self.api.financial_information == None: pass return self.api.financial_information def get_instruments(self, type): #type="crypto"/"forex"/"cfd" time.sleep(self.suspend) self.api.instruments = None while self.api.instruments == None: try: self.api.get_instruments(type) start = time.time() while self.api.instruments == None and time.time() - start < 10: pass except: logging.error('**error** api.get_instruments need reconnect') self.connect() return self.api.instruments def instruments_input_to_ACTIVES(self, type): instruments = self.get_instruments(type) for ins in instruments["instruments"]: OP_code.ACTIVES[ins["id"]] = ins["active_id"] def instruments_input_all_in_ACTIVES(self): self.instruments_input_to_ACTIVES("crypto") self.instruments_input_to_ACTIVES("forex") self.instruments_input_to_ACTIVES("cfd") def get_ALL_Binary_ACTIVES_OPCODE(self): init_info = self.get_all_init() for dirr in (["binary", "turbo"]): for i in init_info["result"][dirr]["actives"]: OP_code.ACTIVES[(init_info["result"][dirr]["actives"][i] ["name"]).split(".")[1]] = int(i) # _________________________self.api.get_api_option_init_all() wss______________________ def get_all_init(self): while True: self.api.api_option_init_all_result = None while True: try: self.api.get_api_option_init_all() break except: logging.error('**error** get_all_init need reconnect') self.connect() time.sleep(5) start = time.time() while True: if time.time() - start > 30: logging.error('**warning** get_all_init late 30 sec') break try: if self.api.api_option_init_all_result != None: break except: pass try: if self.api.api_option_init_all_result["isSuccessful"] == True: return self.api.api_option_init_all_result except: pass def get_all_init_v2(self): self.api.api_option_init_all_result_v2 = None self.api.get_api_option_init_all_v2() start_t = time.time() while self.api.api_option_init_all_result_v2 == None: if time.time() - start_t >= 30: logging.error('**warning** get_all_init_v2 late 30 sec') return None return self.api.api_option_init_all_result_v2 # return OP_code.ACTIVES #------- chek if binary/digit/cfd/stock... if open or not def get_all_open_time(self): #for binary option turbo and binary OPEN_TIME = nested_dict(3, dict) binary_data = self.get_all_init_v2() binary_list = ["binary", "turbo"] for option in binary_list: for actives_id in binary_data[option]["actives"]: active = binary_data[option]["actives"][actives_id] name = str(active["name"]).split(".")[1] if active["enabled"] == True: if active["is_suspended"] == True: OPEN_TIME[option][name]["open"] = False else: OPEN_TIME[option][name]["open"] = True else: OPEN_TIME[option][name]["open"] = active["enabled"] #for digital digital_data = self.get_digital_underlying_list_data()["underlying"] for digital in digital_data: name = digital["underlying"] schedule = digital["schedule"] OPEN_TIME["digital"][name]["open"] = False for schedule_time in schedule: start = schedule_time["open"] end = schedule_time["close"] if start < time.time() < end: OPEN_TIME["digital"][name]["open"] = True #for OTHER instrument_list = ["cfd", "forex", "crypto"] for instruments_type in instrument_list: ins_data = self.get_instruments(instruments_type)["instruments"] for detail in ins_data: name = detail["name"] schedule = detail["schedule"] OPEN_TIME[instruments_type][name]["open"] = False for schedule_time in schedule: start = schedule_time["open"] end = schedule_time["close"] if start < time.time() < end: OPEN_TIME[instruments_type][name]["open"] = True return OPEN_TIME # --------for binary option detail def get_binary_option_detail(self): detail = nested_dict(2, dict) init_info = self.get_all_init() for actives in init_info["result"]["turbo"]["actives"]: name = init_info["result"]["turbo"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] detail[name]["turbo"] = init_info["result"]["turbo"]["actives"][ actives] for actives in init_info["result"]["binary"]["actives"]: name = init_info["result"]["binary"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] detail[name]["binary"] = init_info["result"]["binary"]["actives"][ actives] return detail def get_all_profit(self): all_profit = nested_dict(2, dict) init_info = self.get_all_init() for actives in init_info["result"]["turbo"]["actives"]: name = init_info["result"]["turbo"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] all_profit[name]["turbo"] = (100.0 - init_info["result"]["turbo"][ "actives"][actives]["option"]["profit"]["commission"]) / 100.0 for actives in init_info["result"]["binary"]["actives"]: name = init_info["result"]["binary"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] all_profit[name]["binary"] = ( 100.0 - init_info["result"]["binary"]["actives"][actives] ["option"]["profit"]["commission"]) / 100.0 return all_profit # ---------------------------------------- # ______________________________________self.api.getprofile() https________________________________ def get_profile(self): while True: try: respon = self.api.getprofile().json() time.sleep(self.suspend) if respon["isSuccessful"] == True: return respon except: logging.error('**error** get_profile try reconnect') self.connect() def get_balance_id(self): self.api.profile.balance_id = None while True: try: respon = self.get_profile() self.api.profile.balance_id = respon["result"]["balance_id"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balance(self): self.api.profile.balance = None while True: try: respon = self.get_profile() self.api.profile.balance = respon["result"]["balance"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balances(self): # self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balances = respon["result"]["balances"] break except: logging.error('**error** get_balances()') pass time.sleep(self.suspend) return self.api.profile.balances def get_balance_mode(self): # self.api.profile.balance_type=None while True: try: respon = self.get_profile() self.api.profile.balance_type = respon["result"][ "balance_type"] break except: logging.error('**error** get_balance_mode()') pass time.sleep(self.suspend) if self.api.profile.balance_type == 1: return "REAL" elif self.api.profile.balance_type == 4: return "PRACTICE" def reset_practice_balance(self): self.api.training_balance_reset_request = None self.api.reset_training_balance() while self.api.training_balance_reset_request == None: pass return self.api.training_balance_reset_request def change_balance(self, Balance_MODE): real_id = None practice_id = None while True: try: self.get_balances() for accunt in self.api.profile.balances: if accunt["type"] == 1: real_id = accunt["id"] if accunt["type"] == 4: practice_id = accunt["id"] break except: logging.error('**error** change_balance()') pass while self.get_balance_mode() != Balance_MODE: if Balance_MODE == "REAL": self.api.changebalance(real_id) elif Balance_MODE == "PRACTICE": self.api.changebalance(practice_id) else: logging.error("ERROR doesn't have this mode") exit(1) # ________________________________________________________________________ # _______________________ CANDLE _____________________________ # ________________________self.api.getcandles() wss________________________ def get_candles(self, ACTIVES, interval, count, endtime): self.api.candles.candles_data = None while True: try: self.api.getcandles(OP_code.ACTIVES[ACTIVES], interval, count, endtime) while self.check_connect and self.api.candles.candles_data == None: pass if self.api.candles.candles_data != None: break except: logging.error('**error** get_candles need reconnect') self.connect() return self.api.candles.candles_data ####################################################### # ______________________________________________________ # _____________________REAL TIME CANDLE_________________ # ______________________________________________________ ####################################################### def start_candles_stream(self, ACTIVE, size, maxdict): if size == "all": for s in self.size: self.full_realtime_get_candle(ACTIVE, s, maxdict) self.api.real_time_candles_maxdict_table[ACTIVE][s] = maxdict self.start_candles_all_size_stream(ACTIVE) elif size in self.size: self.api.real_time_candles_maxdict_table[ACTIVE][size] = maxdict self.full_realtime_get_candle(ACTIVE, size, maxdict) self.start_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def stop_candles_stream(self, ACTIVE, size): if size == "all": self.stop_candles_all_size_stream(ACTIVE) elif size in self.size: self.stop_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def get_realtime_candles(self, ACTIVE, size): if size == "all": try: return self.api.real_time_candles[ACTIVE] except: logging.error( '**error** get_realtime_candles() size="all" can not get candle' ) return False elif size in self.size: try: return self.api.real_time_candles[ACTIVE][size] except: logging.error('**error** get_realtime_candles() size=' + str(size) + ' can not get candle') return False else: logging.error( '**error** get_realtime_candles() please input right "size"') def get_all_realtime_candles(self): return self.api.real_time_candles ################################################ # ---------REAL TIME CANDLE Subset Function--------- ################################################ # ---------------------full dict get_candle----------------------- def full_realtime_get_candle(self, ACTIVE, size, maxdict): candles = self.get_candles(ACTIVE, size, maxdict, self.api.timesync.server_timestamp) for can in candles: self.api.real_time_candles[str(ACTIVE)][int(size)][ can["from"]] = can # ------------------------Subscribe ONE SIZE----------------------- def start_candles_one_stream(self, ACTIVE, size): if (str(ACTIVE + "," + str(size)) in self.subscribe_candle) == False: self.subscribe_candle.append((ACTIVE + "," + str(size))) start = time.time() self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} while True: if time.time() - start > 20: logging.error( '**error** start_candles_one_stream late for 20 sec') return False try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == True: return True except: pass try: self.api.subscribe(OP_code.ACTIVES[ACTIVE], size) except: logging.error('**error** start_candles_stream reconnect') self.connect() time.sleep(1) def stop_candles_one_stream(self, ACTIVE, size): if ((ACTIVE + "," + str(size)) in self.subscribe_candle) == True: self.subscribe_candle.remove(ACTIVE + "," + str(size)) while True: try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == {}: return True except: pass self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} self.api.unsubscribe(OP_code.ACTIVES[ACTIVE], size) time.sleep(self.suspend * 10) # ------------------------Subscribe ALL SIZE----------------------- def start_candles_all_size_stream(self, ACTIVE): self.api.candle_generated_all_size_check[str(ACTIVE)] = {} if (str(ACTIVE) in self.subscribe_candle_all_size) == False: self.subscribe_candle_all_size.append(str(ACTIVE)) start = time.time() while True: if time.time() - start > 20: logging.error('**error** fail ' + ACTIVE + ' start_candles_all_size_stream late for 10 sec') return False try: if self.api.candle_generated_all_size_check[str( ACTIVE)] == True: return True except: pass try: self.api.subscribe_all_size(OP_code.ACTIVES[ACTIVE]) except: logging.error( '**error** start_candles_all_size_stream reconnect') self.connect() time.sleep(1) def stop_candles_all_size_stream(self, ACTIVE): if (str(ACTIVE) in self.subscribe_candle_all_size) == True: self.subscribe_candle_all_size.remove(str(ACTIVE)) while True: try: if self.api.candle_generated_all_size_check[str(ACTIVE)] == {}: break except: pass self.api.candle_generated_all_size_check[str(ACTIVE)] = {} self.api.unsubscribe_all_size(OP_code.ACTIVES[ACTIVE]) time.sleep(self.suspend * 10) # ------------------------top_assets_updated--------------------------------------------- def subscribe_top_assets_updated(self, instrument_type): self.api.Subscribe_Top_Assets_Updated(instrument_type) def unsubscribe_top_assets_updated(self, instrument_type): self.api.Unsubscribe_Top_Assets_Updated(instrument_type) def get_top_assets_updated(self, instrument_type): if instrument_type in self.api.top_assets_updated_data: return self.api.top_assets_updated_data[instrument_type] else: return None # ----------------------------------------------- # -----------------traders_mood---------------------- def start_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == False: self.subscribe_mood.append(ACTIVES) while True: self.api.subscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) try: self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] break except: time.sleep(5) def stop_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == True: del self.subscribe_mood[ACTIVES] self.api.unsubscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) def get_traders_mood(self, ACTIVES): # return highter % return self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] def get_all_traders_mood(self): # return highter % return self.api.traders_mood ############################################################################################## def check_win(self, id_number): # 'win':win money 'equal':no win no loose 'loose':loose money while True: try: listinfodata_dict = self.api.listinfodata.get(id_number) if listinfodata_dict["game_state"] == 1: break except: pass self.api.listinfodata.delete(id_number) return listinfodata_dict["win"] def check_win_v2(self, id_number): while True: check, data = self.get_betinfo(id_number) if check: return data["result"]["data"][str(id_number)]["win"] time.sleep(self.suspend) # -------------------get infomation only for binary option------------------------ def get_betinfo(self, id_number): # INPUT:int while True: self.api.game_betinfo.isSuccessful = None start = time.time() try: self.api.get_betinfo(id_number) except: logging.error( '**error** def get_betinfo self.api.get_betinfo reconnect' ) self.connect() while self.api.game_betinfo.isSuccessful == None: if time.time() - start > 10: logging.error( '**error** get_betinfo time out need reconnect') self.connect() self.api.get_betinfo(id_number) time.sleep(self.suspend * 10) if self.api.game_betinfo.isSuccessful == True: return self.api.game_betinfo.isSuccessful, self.api.game_betinfo.dict else: return self.api.game_betinfo.isSuccessful, None time.sleep(self.suspend * 10) def get_optioninfo(self, limit): self.api.api_game_getoptions_result = None self.api.get_options(limit) while self.api.api_game_getoptions_result == None: pass return self.api.api_game_getoptions_result def get_optioninfo_v2(self, limit): self.api.get_options_v2_data = None self.api.get_options_v2(limit, "binary,turbo") while self.api.get_options_v2_data == None: pass return self.api.get_options_v2_data # __________________________BUY__________________________ # __________________FOR OPTION____________________________ def buy_multi(self, price, ACTIVES, ACTION, expirations): self.api.buy_multi_option = {} if len(price) == len(ACTIVES) == len(ACTION) == len(expirations): buy_len = len(price) for idx in range(buy_len): self.api.buyv3(price[idx], OP_code.ACTIVES[ACTIVES[idx]], ACTION[idx], expirations[idx], idx) while len(self.api.buy_multi_option) < buy_len: pass buy_id = [] for key in sorted(self.api.buy_multi_option.keys()): try: value = self.api.buy_multi_option[key] buy_id.append(value["id"]) except: buy_id.append(None) return buy_id else: logging.error('buy_multi error please input all same len') def get_remaning(self, duration): for remaning in get_remaning_time(self.api.timesync.server_timestamp): if remaning[0] == duration: return remaning[1] logging.error('get_remaning(self,duration) ERROR duration') return "ERROR duration" def buy(self, price, ACTIVES, ACTION, expirations): self.api.buy_successful = None self.api.buy_id = None self.api.buy(price, OP_code.ACTIVES[ACTIVES], ACTION, expirations) start_t = time.time() while self.api.buy_successful == None and self.api.buy_id == None: if time.time() - start_t >= 30: logging.error('**warning** buy late 30 sec') return False, None return self.api.buy_successful, self.api.buy_id def sell_option(self, options_ids): self.api.sell_option(options_ids) self.api.sold_options_respond = None while self.api.sold_options_respond == None: pass return self.api.sold_options_respond # __________________for Digital___________________ def get_digital_underlying_list_data(self): self.api.underlying_list_data = None self.api.get_digital_underlying() start_t = time.time() while self.api.underlying_list_data == None: if time.time() - start_t >= 30: logging.error( '**warning** get_digital_underlying_list_data late 30 sec') return None return self.api.underlying_list_data def get_strike_list(self, ACTIVES, duration): self.api.strike_list = None self.api.get_strike_list(ACTIVES, duration) ans = {} while self.api.strike_list == None: pass try: for data in self.api.strike_list["msg"]["strike"]: temp = {} temp["call"] = data["call"]["id"] temp["put"] = data["put"]["id"] ans[("%.6f" % (float(data["value"]) * 10e-7))] = temp except: logging.error('**error** get_strike_list read problem...') return self.api.strike_list, None return self.api.strike_list, ans def subscribe_strike_list(self, ACTIVE, expiration_period): self.api.subscribe_instrument_quites_generated(ACTIVE, expiration_period) def unsubscribe_strike_list(self, ACTIVE, expiration_period): del self.api.instrument_quites_generated_data[ACTIVE] self.api.unsubscribe_instrument_quites_generated( ACTIVE, expiration_period) def get_realtime_strike_list(self, ACTIVE, duration): while True: if not self.api.instrument_quites_generated_data[ACTIVE][duration * 60]: pass else: break """ strike_list dict: price:{call:id,put:id} """ ans = {} now_timestamp = self.api.instrument_quites_generated_timestamp[ACTIVE][ duration * 60] while ans == {}: if self.get_realtime_strike_list_temp_data == {} or now_timestamp != self.get_realtime_strike_list_temp_expiration: raw_data, strike_list = self.get_strike_list(ACTIVE, duration) self.get_realtime_strike_list_temp_expiration = raw_data[ "msg"]["expiration"] self.get_realtime_strike_list_temp_data = strike_list else: strike_list = self.get_realtime_strike_list_temp_data profit = self.api.instrument_quites_generated_data[ACTIVE][duration * 60] for price_key in strike_list: try: side_data = {} for side_key in strike_list[price_key]: detail_data = {} profit_d = profit[strike_list[price_key][side_key]] detail_data["profit"] = profit_d detail_data["id"] = strike_list[price_key][side_key] side_data[side_key] = detail_data ans[price_key] = side_data except: pass return ans def get_digital_current_profit(self, ACTIVE, duration): profit = self.api.instrument_quites_generated_data[ACTIVE][duration * 60] for key in profit: if key.find("SPT") != -1: return profit[key] return False #thank thiagottjv #https://github.com/Lu-Yi-Hsun/iqoptionapi/issues/65#issuecomment-513998357 def buy_digital_spot(self, active, amount, action, duration): #Expiration time need to be formatted like this: YYYYMMDDHHII #And need to be on GMT time #Type - P or C if action == 'put': action = 'P' elif action == 'call': action = 'C' else: logging.error('buy_digital_spot active error') return -1 #doEURUSD201907191250PT5MPSPT timestamp = int(self.api.timesync.server_timestamp) if duration == 1: exp, _ = get_expiration_time(timestamp, duration) else: now_date = datetime.fromtimestamp(timestamp) + timedelta( minutes=1, seconds=30) while True: if now_date.minute % duration == 0 and time.mktime( now_date.timetuple()) - timestamp > 30: break now_date = now_date + timedelta(minutes=1) exp = time.mktime(now_date.timetuple()) dateFormated = str( datetime.utcfromtimestamp(exp).strftime("%Y%m%d%H%M")) instrument_id = "do" + active + dateFormated + "PT" + str( duration) + "M" + action + "SPT" self.api.digital_option_placed_id = None self.api.place_digital_option(instrument_id, amount) while self.api.digital_option_placed_id == None: pass return self.api.digital_option_placed_id def buy_digital(self, amount, instrument_id): self.api.digital_option_placed_id = None self.api.place_digital_option(instrument_id, amount) start_t = time.time() while self.api.digital_option_placed_id == None: if time.time() - start_t > 30: logging.error('buy_digital loss digital_option_placed_id') return False, None return True, self.api.digital_option_placed_id def close_digital_option(self, position_id): self.api.result = None while self.get_async_order(position_id) == None: pass position_changed = self.get_async_order(position_id) self.api.close_digital_option(position_changed["id"]) while self.api.result == None: pass return self.api.result def check_win_digital(self, buy_order_id): data = self.get_digital_position(buy_order_id) if data["msg"]["position"]["status"] == "closed": if data["msg"]["position"]["close_reason"] == "default": return True, data["msg"]["position"]["pnl_realized"] elif data["msg"]["position"]["close_reason"] == "expired": return True, data["msg"]["position"]["pnl_realized"] - data[ "msg"]["position"]["buy_amount"] else: return False, None def check_win_digital_v2(self, buy_order_id): order_data = self.get_async_order(buy_order_id) if order_data != None: if order_data["status"] == "closed": if order_data["close_reason"] == "expired": if order_data["close_effect_amount"] == 0: return True, -1 * max(order_data["buy_amount"], order_data["sell_amount"]) else: return True, order_data["close_effect_amount"] - max( order_data["buy_amount"], order_data["sell_amount"]) elif order_data["close_reason"] == "default": return True, order_data["pnl_realized_enrolled"] else: return False, None else: return False, None # ---------------------------------------------------------- # -----------------BUY_for__Forex__&&__stock(cfd)__&&__ctrpto def buy_order(self, instrument_type, instrument_id, side, amount, leverage, type, limit_price=None, stop_price=None, stop_lose_kind=None, stop_lose_value=None, take_profit_kind=None, take_profit_value=None, use_trail_stop=False, auto_margin_call=False, use_token_for_commission=False): self.api.buy_order_id = None self.api.buy_order(instrument_type=instrument_type, instrument_id=instrument_id, side=side, amount=amount, leverage=leverage, type=type, limit_price=limit_price, stop_price=stop_price, stop_lose_value=stop_lose_value, stop_lose_kind=stop_lose_kind, take_profit_value=take_profit_value, take_profit_kind=take_profit_kind, use_trail_stop=use_trail_stop, auto_margin_call=auto_margin_call, use_token_for_commission=use_token_for_commission) while self.api.buy_order_id == None: pass check, data = self.get_order(self.api.buy_order_id) while data["status"] == "pending_new": check, data = self.get_order(self.api.buy_order_id) time.sleep(1) if check: if data["status"] != "rejected": return True, self.api.buy_order_id else: return False, None else: return False, None def change_auto_margin_call(self, ID_Name, ID, auto_margin_call): self.api.auto_margin_call_changed_respond = None self.api.change_auto_margin_call(ID_Name, ID, auto_margin_call) while self.api.auto_margin_call_changed_respond == None: pass if self.api.auto_margin_call_changed_respond["status"] == 2000: return True, self.api.auto_margin_call_changed_respond else: return False, self.api.auto_margin_call_changed_respond def change_order(self, ID_Name, order_id, stop_lose_kind, stop_lose_value, take_profit_kind, take_profit_value, use_trail_stop, auto_margin_call): check = True if ID_Name == "position_id": check, order_data = self.get_order(order_id) position_id = order_data["position_id"] ID = position_id elif ID_Name == "order_id": ID = order_id else: logging.error('change_order input error ID_Name') if check: self.api.tpsl_changed_respond = None self.api.change_order(ID_Name=ID_Name, ID=ID, stop_lose_kind=stop_lose_kind, stop_lose_value=stop_lose_value, take_profit_kind=take_profit_kind, take_profit_value=take_profit_value, use_trail_stop=use_trail_stop) self.change_auto_margin_call(ID_Name=ID_Name, ID=ID, auto_margin_call=auto_margin_call) while self.api.tpsl_changed_respond == None: pass if self.api.tpsl_changed_respond["status"] == 2000: return True, self.api.tpsl_changed_respond["msg"] else: return False, self.api.tpsl_changed_respond else: logging.error('change_order fail to get position_id') return False, None def get_async_order(self, buy_order_id): if buy_order_id in self.api.position_changed_data: return self.api.position_changed_data[buy_order_id] elif buy_order_id in self.api.microserviceName_binary_options_name_option: return self.api.microserviceName_binary_options_name_option[ buy_order_id] else: return None def get_order(self, buy_order_id): # self.api.order_data["status"] # reject:you can not get this order # pending_new:this order is working now # filled:this order is ok now # new self.api.order_data = None self.api.get_order(buy_order_id) while self.api.order_data == None: pass if self.api.order_data["status"] == 2000: return True, self.api.order_data["msg"] else: return False, None def get_pending(self, instrument_type): self.api.deferred_orders = None self.api.get_pending(instrument_type) while self.api.deferred_orders == None: pass if self.api.deferred_orders["status"] == 2000: return True, self.api.deferred_orders["msg"] else: return False, None # this function is heavy def get_positions(self, instrument_type): self.api.positions = None self.api.get_positions(instrument_type) while self.api.positions == None: pass if self.api.positions["status"] == 2000: return True, self.api.positions["msg"] else: return False, None def get_position(self, buy_order_id): self.api.position = None check, order_data = self.get_order(buy_order_id) position_id = order_data["position_id"] self.api.get_position(position_id) while self.api.position == None: pass if self.api.position["status"] == 2000: return True, self.api.position["msg"] else: return False, None # this function is heavy def get_digital_position(self, order_id): self.api.position = None while self.get_async_order(order_id) == None: pass position_id = self.get_async_order(order_id)["id"] self.api.get_digital_position(position_id) while self.api.position == None: pass return self.api.position def get_position_history(self, instrument_type): self.api.position_history = None self.api.get_position_history(instrument_type) while self.api.position_history == None: pass if self.api.position_history["status"] == 2000: return True, self.api.position_history["msg"] else: return False, None def get_position_history_v2(self, instrument_type, limit, offset, start, end): #instrument_type=crypto forex fx-option multi-option cfd digital-option turbo-option self.api.position_history_v2 = None self.api.get_position_history_v2(instrument_type, limit, offset, start, end) while self.api.position_history_v2 == None: pass if self.api.position_history_v2["status"] == 2000: return True, self.api.position_history_v2["msg"] else: return False, None def get_available_leverages(self, instrument_type, actives): self.api.available_leverages = None self.api.get_available_leverages(instrument_type, OP_code.ACTIVES[actives]) while self.api.available_leverages == None: pass if self.api.available_leverages["status"] == 2000: return True, self.api.available_leverages["msg"] else: return False, None def cancel_order(self, buy_order_id): self.api.order_canceled = None self.api.cancel_order(buy_order_id) while self.api.order_canceled == None: pass if self.api.order_canceled["status"] == 2000: return True else: return False def close_position(self, position_id): check, data = self.get_order(position_id) if data["position_id"] != None: self.api.close_position_data = None self.api.close_position(data["position_id"]) while self.api.close_position_data == None: pass if self.api.close_position_data["status"] == 2000: return True else: return False else: return False def close_position_v2(self, position_id): while self.get_async_order(position_id) == None: pass position_changed = self.get_async_order(position_id) self.api.close_position(position_changed["id"]) while self.api.close_position_data == None: pass if self.api.close_position_data["status"] == 2000: return True else: return False def get_overnight_fee(self, instrument_type, active): self.api.overnight_fee = None self.api.get_overnight_fee(instrument_type, OP_code.ACTIVES[active]) while self.api.overnight_fee == None: pass if self.api.overnight_fee["status"] == 2000: return True, self.api.overnight_fee["msg"] else: return False, None
import urllib3 import time from iqoptionapi.api import IQOptionAPI from websocket import create_connection import json ws = create_connection( "wss://iqoption.com/echo/{randomnumber}/{randomnumber}/websocket") print "Sending 'Cookie'..." ws.send("{'msg': 'MY COOKIE ID', 'name': 'ssid'}") print "Sent" print "Reeiving..." result = ws.recv() print "Received '%s'" % result urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) api = IQOptionAPI("iqoption.com", "*****@*****.**", "y61327061") api.connect() time.sleep(2) balance = api.profile.balance time.sleep(2) print balance api.setactives([73, 2]) time.sleep(2) api.getcandles(1, 1) time.sleep(2) data = api.candles.candles_data print api.candles.candles_data
from iqoptionapi.api import IQOptionAPI import json import iqoptionapi.constants as api_constants from time import gmtime, strftime import time api = IQOptionAPI("iqoption.com", "*****@*****.**", "ad318717") api.connect() time.sleep(5) #api.setactives([api_constants.ACTIVES["EURUSD"], api_constants.ACTIVES["EURUSD-OTC"]]) api.setactives([1, 1]) time.sleep(5) api.getcandles(1, 1) time.sleep(5) data = api.candles.candles_data print(api.candles.candles_data) print("local time is") sec = strftime("%S", gmtime()) while True: sec = strftime("%S", gmtime()) if sec == "59": print("should be here") api.buy(1, 1, "binary", "put") time.sleep(5) #for key in api_constants.ACTIVES: #print key, 'corresponds to', api_constants.ACTIVES[key]
class IQ_Option: __version__ = "3.6.4" def __init__(self, email, password): self.size = [ 1, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800, 3600, 7200, 14400, 28800, 43200, 86400, 604800, 2592000 ] self.email = email self.password = password self.suspend = 0.5 self.thread = None self.subscribe_candle = [] self.subscribe_candle_all_size = [] self.subscribe_mood = [] # for digit self.get_realtime_strike_list_temp_data = {} self.get_realtime_strike_list_temp_expiration = 0 # self.max_reconnect = 5 self.connect_count = 0 # --start self.connect() # self.update_ACTIVES_OPCODE() this auto function delay too long self.get_balance_id() # -------------------------------------------------------------------------- def get_server_timestamp(self): return self.api.timesync.server_timestamp def set_max_reconnect(self, number): self.max_reconnect = number def connect(self): while True: try: self.api.close() except: pass #logging.error('**warning** self.api.close() fail') if self.connect_count < self.max_reconnect: self.api = IQOptionAPI("iqoption.com", self.email, self.password) check = None try: check = self.api.connect() except: logging.error('**error** connect() fail') if check == True: # -------------reconnect subscribe_candle try: for ac in self.subscribe_candle: sp = ac.split(",") self.start_candles_one_stream(sp[0], sp[1]) except: pass # ----------------- try: for ac in self.subscribe_candle_all_size: self.start_candles_all_size_stream(ac) except: pass # -------------reconnect subscribe_mood try: for ac in self.subscribe_mood: self.start_mood_stream(ac) except: pass break time.sleep(self.suspend * 2) self.connect_count = self.connect_count + 1 else: logging.error( '**error** reconnect() too many time please look log file') exit(1) def check_connect(self): # True/False idle_time = abs(self.api.timesync.server_timestamp - time.time()) if idle_time > 6: return False else: return True # wait for timestamp getting # _________________________UPDATE ACTIVES OPCODE_____________________ def get_all_ACTIVES_OPCODE(self): return OP_code.ACTIVES def update_ACTIVES_OPCODE(self): # update from binary option self.get_ALL_Binary_ACTIVES_OPCODE() #crypto /dorex/cfd self.instruments_input_all_in_ACTIVES() dicc = {} for lis in sorted(OP_code.ACTIVES.items(), key=operator.itemgetter(1)): dicc[lis[0]] = lis[1] OP_code.ACTIVES = dicc def get_name_by_activeId(self, activeId): info = self.get_financial_information(activeId) try: return info["msg"]["data"]["active"]["name"] except: return None def get_financial_information(self, activeId): self.api.financial_information = None self.api.get_financial_information(activeId) while self.api.financial_information == None: pass return self.api.financial_information def get_instruments(self, type): #type="crypto"/"forex"/"cfd" time.sleep(self.suspend) self.api.instruments = None while self.api.instruments == None: try: self.api.get_instruments(type) start = time.time() while self.api.instruments == None and time.time() - start < 10: pass except: logging.error('**error** api.get_instruments need reconnect') self.connect() return self.api.instruments def instruments_input_to_ACTIVES(self, type): instruments = self.get_instruments(type) for ins in instruments["instruments"]: OP_code.ACTIVES[ins["id"]] = ins["active_id"] def instruments_input_all_in_ACTIVES(self): self.instruments_input_to_ACTIVES("crypto") self.instruments_input_to_ACTIVES("forex") self.instruments_input_to_ACTIVES("cfd") def get_ALL_Binary_ACTIVES_OPCODE(self): init_info = self.get_all_init() for i in init_info["result"]["binary"]["actives"]: OP_code.ACTIVES[(init_info["result"]["binary"]["actives"][i] ["name"]).split(".")[1]] = int(i) # _________________________self.api.get_api_option_init_all() wss______________________ def get_all_init(self): while True: self.api.api_option_init_all_result = None while True: try: self.api.get_api_option_init_all() break except: logging.error('**error** get_all_init need reconnect') self.connect() time.sleep(5) start = time.time() while True: if time.time() - start > 30: logging.error('**warning** get_all_init late 30 sec') break try: if self.api.api_option_init_all_result != None: break except: pass try: if self.api.api_option_init_all_result["isSuccessful"] == True: return self.api.api_option_init_all_result except: pass # return OP_code.ACTIVES # --------for binary option detail def get_binary_option_detail(self): detail = nested_dict(2, dict) init_info = self.get_all_init() for actives in init_info["result"]["turbo"]["actives"]: name = init_info["result"]["turbo"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] detail[name]["turbo"] = init_info["result"]["turbo"]["actives"][ actives] for actives in init_info["result"]["binary"]["actives"]: name = init_info["result"]["binary"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] detail[name]["binary"] = init_info["result"]["binary"]["actives"][ actives] return detail def get_all_profit(self): all_profit = nested_dict(2, dict) init_info = self.get_all_init() for actives in init_info["result"]["turbo"]["actives"]: name = init_info["result"]["turbo"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] all_profit[name]["turbo"] = (100.0 - init_info["result"]["turbo"][ "actives"][actives]["option"]["profit"]["commission"]) / 100.0 for actives in init_info["result"]["binary"]["actives"]: name = init_info["result"]["binary"]["actives"][actives]["name"] name = name[name.index(".") + 1:len(name)] all_profit[name]["binary"] = ( 100.0 - init_info["result"]["binary"]["actives"][actives] ["option"]["profit"]["commission"]) / 100.0 return all_profit # ---------------------------------------- # ______________________________________self.api.getprofile() https________________________________ def get_profile(self): while True: try: respon = self.api.getprofile().json() time.sleep(self.suspend) if respon["isSuccessful"] == True: return respon except: logging.error('**error** get_profile try reconnect') self.connect() def get_balance_id(self): self.api.profile.balance_id = None while True: try: respon = self.get_profile() self.api.profile.balance_id = respon["result"]["balance_id"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balance(self): self.api.profile.balance = None while True: try: respon = self.get_profile() self.api.profile.balance = respon["result"]["balance"] break except: logging.error('**error** get_balance()') time.sleep(self.suspend) return self.api.profile.balance def get_balances(self): # self.api.profile.balance=None while True: try: respon = self.get_profile() self.api.profile.balances = respon["result"]["balances"] break except: logging.error('**error** get_balances()') pass time.sleep(self.suspend) return self.api.profile.balances def get_balance_mode(self): # self.api.profile.balance_type=None while True: try: respon = self.get_profile() self.api.profile.balance_type = respon["result"][ "balance_type"] break except: logging.error('**error** get_balance_mode()') pass time.sleep(self.suspend) if self.api.profile.balance_type == 1: return "REAL" elif self.api.profile.balance_type == 4: return "PRACTICE" def change_balance(self, Balance_MODE): real_id = None practice_id = None while True: try: self.get_balances() for accunt in self.api.profile.balances: if accunt["type"] == 1: real_id = accunt["id"] if accunt["type"] == 4: practice_id = accunt["id"] break except: logging.error('**error** change_balance()') pass while self.get_balance_mode() != Balance_MODE: if Balance_MODE == "REAL": self.api.changebalance(real_id) elif Balance_MODE == "PRACTICE": self.api.changebalance(practice_id) else: logging.error("ERROR doesn't have this mode") exit(1) # ________________________________________________________________________ # _______________________ CANDLE _____________________________ # ________________________self.api.getcandles() wss________________________ def get_candles(self, ACTIVES, interval, count, endtime): self.api.candles.candles_data = None while True: try: self.api.getcandles(OP_code.ACTIVES[ACTIVES], interval, count, endtime) while self.check_connect and self.api.candles.candles_data == None: pass if self.api.candles.candles_data != None: break except: logging.error('**error** get_candles need reconnect') self.connect() return self.api.candles.candles_data ####################################################### # ______________________________________________________ # _____________________REAL TIME CANDLE_________________ # ______________________________________________________ ####################################################### def start_candles_stream(self, ACTIVE, size, maxdict): if size == "all": for s in self.size: self.full_realtime_get_candle(ACTIVE, s, maxdict) self.api.real_time_candles_maxdict_table[ACTIVE][s] = maxdict self.start_candles_all_size_stream(ACTIVE) elif size in self.size: self.api.real_time_candles_maxdict_table[ACTIVE][size] = maxdict self.full_realtime_get_candle(ACTIVE, size, maxdict) self.start_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def stop_candles_stream(self, ACTIVE, size): if size == "all": self.stop_candles_all_size_stream(ACTIVE) elif size in self.size: self.stop_candles_one_stream(ACTIVE, size) else: logging.error( '**error** start_candles_stream please input right size') def get_realtime_candles(self, ACTIVE, size): if size == "all": try: return self.api.real_time_candles[ACTIVE] except: logging.error( '**error** get_realtime_candles() size="all" can not get candle' ) return False elif size in self.size: try: return self.api.real_time_candles[ACTIVE][size] except: logging.error('**error** get_realtime_candles() size=' + str(size) + ' can not get candle') return False else: logging.error( '**error** get_realtime_candles() please input right "size"') def get_all_realtime_candles(self): return self.api.real_time_candles ################################################ # ---------REAL TIME CANDLE Subset Function--------- ################################################ # ---------------------full dict get_candle----------------------- def full_realtime_get_candle(self, ACTIVE, size, maxdict): candles = self.get_candles(ACTIVE, size, maxdict, self.api.timesync.server_timestamp) for can in candles: self.api.real_time_candles[str(ACTIVE)][int(size)][ can["from"]] = can # ------------------------Subscribe ONE SIZE----------------------- def start_candles_one_stream(self, ACTIVE, size): if (str(ACTIVE + "," + str(size)) in self.subscribe_candle) == False: self.subscribe_candle.append((ACTIVE + "," + str(size))) start = time.time() self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} while True: if time.time() - start > 20: logging.error( '**error** start_candles_one_stream late for 20 sec') return False try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == True: return True except: pass try: self.api.subscribe(OP_code.ACTIVES[ACTIVE], size) except: logging.error('**error** start_candles_stream reconnect') self.connect() time.sleep(1) def stop_candles_one_stream(self, ACTIVE, size): if ((ACTIVE + "," + str(size)) in self.subscribe_candle) == True: self.subscribe_candle.remove(ACTIVE + "," + str(size)) while True: try: if self.api.candle_generated_check[str(ACTIVE)][int( size)] == {}: return True except: pass self.api.candle_generated_check[str(ACTIVE)][int(size)] = {} self.api.unsubscribe(OP_code.ACTIVES[ACTIVE], size) time.sleep(self.suspend * 10) # ------------------------Subscribe ALL SIZE----------------------- def start_candles_all_size_stream(self, ACTIVE): self.api.candle_generated_all_size_check[str(ACTIVE)] = {} if (str(ACTIVE) in self.subscribe_candle_all_size) == False: self.subscribe_candle_all_size.append(str(ACTIVE)) start = time.time() while True: if time.time() - start > 20: logging.error('**error** fail ' + ACTIVE + ' start_candles_all_size_stream late for 10 sec') return False try: if self.api.candle_generated_all_size_check[str( ACTIVE)] == True: return True except: pass try: self.api.subscribe_all_size(OP_code.ACTIVES[ACTIVE]) except: logging.error( '**error** start_candles_all_size_stream reconnect') self.connect() time.sleep(1) def stop_candles_all_size_stream(self, ACTIVE): if (str(ACTIVE) in self.subscribe_candle_all_size) == True: self.subscribe_candle_all_size.remove(str(ACTIVE)) while True: try: if self.api.candle_generated_all_size_check[str(ACTIVE)] == {}: break except: pass self.api.candle_generated_all_size_check[str(ACTIVE)] = {} self.api.unsubscribe_all_size(OP_code.ACTIVES[ACTIVE]) time.sleep(self.suspend * 10) # --------------------------------------------------------------------- ################################################ ################################################ # ----------------------------------------------- # -----------------traders_mood---------------------- def start_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == False: self.subscribe_mood.append(ACTIVES) while True: self.api.subscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) try: self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] break except: time.sleep(5) def stop_mood_stream(self, ACTIVES): if ACTIVES in self.subscribe_mood == True: del self.subscribe_mood[ACTIVES] self.api.unsubscribe_Traders_mood(OP_code.ACTIVES[ACTIVES]) def get_traders_mood(self, ACTIVES): # return highter % return self.api.traders_mood[OP_code.ACTIVES[ACTIVES]] def get_all_traders_mood(self): # return highter % return self.api.traders_mood ############################################################################################## def check_win(self, id_number): # 'win':win money 'equal':no win no loose 'loose':loose money while True: try: listinfodata_dict = self.api.listinfodata.get(id_number) if listinfodata_dict["game_state"] == 1: break except: pass self.api.listinfodata.delete(id_number) return listinfodata_dict["win"] def check_win_v2(self, id_number): while True: check, data = self.get_betinfo(id_number) if check: return data["result"]["data"][str(id_number)]["win"] time.sleep(self.suspend) # -------------------get infomation only for binary option------------------------ def get_betinfo(self, id_number): # INPUT:int while True: self.api.game_betinfo.isSuccessful = None start = time.time() try: self.api.get_betinfo(id_number) except: logging.error( '**error** def get_betinfo self.api.get_betinfo reconnect' ) self.connect() while self.api.game_betinfo.isSuccessful == None: if time.time() - start > 10: logging.error( '**error** get_betinfo time out need reconnect') self.connect() self.api.get_betinfo(id_number) time.sleep(self.suspend * 10) if self.api.game_betinfo.isSuccessful == True: return self.api.game_betinfo.isSuccessful, self.api.game_betinfo.dict else: return self.api.game_betinfo.isSuccessful, None time.sleep(self.suspend * 10) def get_optioninfo(self, limit): self.api.api_game_getoptions_result = None self.api.get_options(limit) while self.api.api_game_getoptions_result == None: pass return self.api.api_game_getoptions_result # __________________________BUY__________________________ # __________________FOR OPTION____________________________ def buy_multi(self, price, ACTIVES, ACTION, expirations): self.api.buy_multi_option = {} if len(price) == len(ACTIVES) == len(ACTION) == len(expirations): buy_len = len(price) for idx in range(buy_len): self.api.buyv3(price[idx], OP_code.ACTIVES[ACTIVES[idx]], ACTION[idx], expirations[idx], idx) while len(self.api.buy_multi_option) < buy_len: pass buy_id = [] for key in sorted(self.api.buy_multi_option.keys()): value = self.api.buy_multi_option[key] buy_id.append(value["id"]) return buy_id else: logging.error('buy_multi error please input all same len') def buy(self, price, ACTIVES, ACTION, expirations, force_buy=False): self.api.buy_successful = None self.api.buy_id = None while True: while True: try: self.api.buy(price, OP_code.ACTIVES[ACTIVES], ACTION, expirations) break except: logging.error('self.api.buy error') if force_buy == False: return (None) self.connect() pass start = time.time() while self.api.buy_successful == None or self.api.buy_id == None: if time.time() - start > 60: logging.error('check buy_successful time late 60sec') break if self.api.buy_successful: return (self.api.buy_id) else: if force_buy == False: return (None) logging.error('**error** buy error...') self.connect() def sell_option(self, options_ids): self.api.sell_option(options_ids) self.api.sold_options_respond = None while self.api.sold_options_respond == None: pass return self.api.sold_options_respond # __________________for Digital___________________ def get_strike_list(self, ACTIVES, duration): self.api.strike_list = None self.api.get_strike_list(ACTIVES, duration) ans = {} while self.api.strike_list == None: pass try: for data in self.api.strike_list["msg"]["strike"]: temp = {} temp["call"] = data["call"]["id"] temp["put"] = data["put"]["id"] ans[("%.6f" % (float(data["value"]) * 10e-7))] = temp except: logging.error('**error** get_strike_list read problem...') return self.api.strike_list, None return self.api.strike_list, ans def subscribe_strike_list(self, ACTIVE): self.api.subscribe_instrument_quites_generated(ACTIVE) def unsubscribe_strike_list(self, ACTIVE): del self.api.instrument_quites_generated_data[ACTIVE] self.api.unsubscribe_instrument_quites_generated(ACTIVE) def get_realtime_strike_list(self, ACTIVE, duration): while True: if not self.api.instrument_quites_generated_data[ACTIVE][duration * 60]: pass else: break """ strike_list dict: price:{call:id,put:id} """ ans = {} now_timestamp = self.api.instrument_quites_generated_timestamp[ACTIVE][ duration * 60] while ans == {}: if self.get_realtime_strike_list_temp_data == {} or now_timestamp != self.get_realtime_strike_list_temp_expiration: raw_data, strike_list = self.get_strike_list(ACTIVE, duration) self.get_realtime_strike_list_temp_expiration = raw_data[ "msg"]["expiration"] self.get_realtime_strike_list_temp_data = strike_list else: strike_list = self.get_realtime_strike_list_temp_data profit = self.api.instrument_quites_generated_data[ACTIVE][duration * 60] for price_key in strike_list: try: side_data = {} for side_key in strike_list[price_key]: detail_data = {} profit_d = profit[strike_list[price_key][side_key]] detail_data["profit"] = profit_d detail_data["id"] = strike_list[price_key][side_key] side_data[side_key] = detail_data ans[price_key] = side_data except: pass return ans def buy_digital(self, amount, instrument_id): self.api.position_changed = None return self.buy_order(instrument_type="digital-option", instrument_id=instrument_id, side="buy", type="market", amount=amount, limit_price=0, leverage=1) def check_win_digital(self, buy_order_id): check, data = self.get_position(buy_order_id) if check: if data["position"]["status"] == "closed": return True, data["position"]["close_effect_amount"] else: return False, None else: return False, None # ---------------------------------------------------------- # -----------------BUY_for__Forex__&&__stock(cfd)__&&__ctrpto def buy_order(self, instrument_type, instrument_id, side, amount, leverage, type, limit_price=None, stop_price=None, stop_lose_kind=None, stop_lose_value=None, take_profit_kind=None, take_profit_value=None, use_trail_stop=False, auto_margin_call=False, use_token_for_commission=False): self.api.buy_order_id = None self.api.buy_order(instrument_type=instrument_type, instrument_id=instrument_id, side=side, amount=amount, leverage=leverage, type=type, limit_price=limit_price, stop_price=stop_price, stop_lose_value=stop_lose_value, stop_lose_kind=stop_lose_kind, take_profit_value=take_profit_value, take_profit_kind=take_profit_kind, use_trail_stop=use_trail_stop, auto_margin_call=auto_margin_call, use_token_for_commission=use_token_for_commission) while self.api.buy_order_id == None: pass check, data = self.get_order(self.api.buy_order_id) while data["status"] == "pending_new": check, data = self.get_order(self.api.buy_order_id) time.sleep(1) if check: if data["status"] != "rejected": return True, self.api.buy_order_id else: return False, None else: return False, None def change_auto_margin_call(self, ID_Name, ID, auto_margin_call): self.api.auto_margin_call_changed_respond = None self.api.change_auto_margin_call(ID_Name, ID, auto_margin_call) while self.api.auto_margin_call_changed_respond == None: pass if self.api.auto_margin_call_changed_respond["status"] == 2000: return True, self.api.auto_margin_call_changed_respond else: return False, self.api.auto_margin_call_changed_respond def change_order(self, ID_Name, order_id, stop_lose_kind, stop_lose_value, take_profit_kind, take_profit_value, use_trail_stop, auto_margin_call): check = True if ID_Name == "position_id": check, order_data = self.get_order(order_id) position_id = order_data["position_id"] ID = position_id elif ID_Name == "order_id": ID = order_id else: logging.error('change_order input error ID_Name') if check: self.api.tpsl_changed_respond = None self.api.change_order(ID_Name=ID_Name, ID=ID, stop_lose_kind=stop_lose_kind, stop_lose_value=stop_lose_value, take_profit_kind=take_profit_kind, take_profit_value=take_profit_value, use_trail_stop=use_trail_stop) self.change_auto_margin_call(ID_Name=ID_Name, ID=ID, auto_margin_call=auto_margin_call) while self.api.tpsl_changed_respond == None: pass if self.api.tpsl_changed_respond["status"] == 2000: return True, self.api.tpsl_changed_respond["msg"] else: return False, self.api.tpsl_changed_respond else: logging.error('change_order fail to get position_id') return False, None def get_order(self, buy_order_id): # self.api.order_data["status"] # reject:you can not get this order # pending_new:this order is working now # filled:this order is ok now # new self.api.order_data = None self.api.get_order(buy_order_id) while self.api.order_data == None: pass if self.api.order_data["status"] == 2000: return True, self.api.order_data["msg"] else: return False, None def get_pending(self, instrument_type): self.api.deferred_orders = None self.api.get_pending(instrument_type) while self.api.deferred_orders == None: pass if self.api.deferred_orders["status"] == 2000: return True, self.api.deferred_orders["msg"] else: return False, None # this function is heavy def get_positions(self, instrument_type): self.api.positions = None self.api.get_positions(instrument_type) while self.api.positions == None: pass if self.api.positions["status"] == 2000: return True, self.api.positions["msg"] else: return False, None def get_position(self, buy_order_id): self.api.position = None check, order_data = self.get_order(buy_order_id) position_id = order_data["position_id"] self.api.get_position(position_id) while self.api.position == None: pass if self.api.position["status"] == 2000: return True, self.api.position["msg"] else: return False, None # this function is heavy def get_position_history(self, instrument_type): self.api.position_history = None self.api.get_position_history(instrument_type) while self.api.position_history == None: pass if self.api.position_history["status"] == 2000: return True, self.api.position_history["msg"] else: return False, None def get_available_leverages(self, instrument_type, actives): self.api.available_leverages = None self.api.get_available_leverages(instrument_type, OP_code.ACTIVES[actives]) while self.api.available_leverages == None: pass if self.api.available_leverages["status"] == 2000: return True, self.api.available_leverages["msg"] else: return False, None def cancel_order(self, buy_order_id): self.api.order_canceled = None self.api.cancel_order(buy_order_id) while self.api.order_canceled == None: pass if self.api.order_canceled["status"] == 2000: return True else: return False def close_position(self, buy_order_id): check, data = self.get_order(buy_order_id) if data["position_id"] != None: self.api.close_position_data = None self.api.close_position(data["position_id"]) while self.api.close_position_data == None: pass if self.api.close_position_data["status"] == 2000: return True else: return False else: return False def get_overnight_fee(self, instrument_type, active): self.api.overnight_fee = None self.api.get_overnight_fee(instrument_type, OP_code.ACTIVES[active]) while self.api.overnight_fee == None: pass if self.api.overnight_fee["status"] == 2000: return True, self.api.overnight_fee["msg"] else: return False, None
class IQOption(): def __init__(self, user=userdata.mainUser, active_id="EURUSD"): self.username = user['username'] self.password = user['password'] self.real = user['real'] self.demo = user['demo'] self.active_id = active_id self.api = IQOptionAPI("iqoption.com", self.username, self.password) self.api.connect() self.setExpirationTime() self.setActives(self.active_id) self.api.changebalance(self.demo) def openPosition(self, direction, amount=1): while self.api.timesync.server_datetime.second != 0: sleep(0.5) self.api.buy(amount, api_constants.ACTIVES[self.active_id], "turbo", direction) def getBalance(self): return self.api.profile.balance def setExpirationTime(self, time=1): self.api.timesync.expiration_time = time def setActives(self, activeID): self.active_id = activeID self.api.setactives([api_constants.ACTIVES[self.active_id]]) def getCandles(self, duration=1): self.api.getcandles(api_constants.ACTIVES[self.active_id], duration) candles = self.api.candles.candles_data while not candles: sleep(0.1) self.api.getcandles(api_constants.ACTIVES[self.active_id], duration) candles = self.api.candles.candles_data if candles: # print 'Timestamp: ', datetime.datetime.fromtimestamp(int(candles[-1][0])).strftime('%Y-%m-%d %H:%M:%S') # print 'Open: ', candles[-1][1] # print 'Close: ', candles[-1][2] # print 'High: ', candles[-1][3] # print 'Low: ', candles[-1][4] return candles[-3], candles[-2], candles[-1] else: print('Invalid Candle!') return None def getServerDateTime(self): print(str(self.api.timesync.server_datetime)) return str(self.api.timesync.server_datetime) def getExpirationDateTime(self): print(str(self.api.timesync.expiration_datetime)) return str(self.api.timesync.expiration_datetime) def getResult(self): try: result = self.api.listinfodata.current_listinfodata.win #print('Result: ' + result) return result except: print('Result Error!') return None def changeBalance(self, real=False): # To enable the real account: if real: self.api.changebalance(self.real) else: self.api.changebalance(self.demo) #self.api.change_balance('practice') def getDataFrame(self, duration=1): candles = self.getCandles(duration) if candles: try: # candlesDF -> dict type candlesDF = { 'DateTime': [candles[-3][0], candles[-2][0]], # candles[-1][0]], 'Open': [candles[-3][1], candles[-2][1]], # candles[-1][1]], 'Close': [candles[-3][2], candles[-2][2]], # candles[-1][2]], 'High': [candles[-3][3], candles[-2][3]], # candles[-1][3]], 'Low': [candles[-3][4], candles[-2][4]] # , candles[-1][4]] } except: return None return candlesDF