def __init__(self): api: str = 'BINANCE_API_KEY' secret: str = 'BINANCE_SECRET_KEY' api_key: str = os.environ[api] if api in os.environ else 'test' secret_key: str = os.environ[secret] if secret in os.environ else 'test' self.client = RequestClient(api_key=api_key, secret_key=secret_key) self.log = logging.getLogger(name='DataRetriever')
def send_order(position, safe=False): if not safe: try: print('trying to send Order:\n', position) request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.post_order(symbol=position.ticker, side=position.side, ordertype=OrderType.MARKET, quantity=position.quantity) # PrintBasic.print_obj(result) return True except Exception as e: print(e) BinanceFutures.current_exception = e time.sleep(1) return False else: sleep_time = 1 while True: result = BinanceFutures.send_order(position, safe=False) if result: break else: logger.log('Exception in safe_open_order execution:\n' + str( BinanceFutures.current_exception) + '\n\nSleeping for' + str(sleep_time) + 'seconds') time.sleep(sleep_time) sleep_time *= 2
def short_ETH(size): request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.post_order(symbol="ETHUSDT", side=OrderSide.SELL, ordertype=OrderType.MARKET, quantity=size) # PrintBasic.print_obj(result) return result
def __init__(self, requests_only=False): super().__init__() if not requests_only: self.sub_client = SubscriptionClient(api_key=self.api_key, secret_key=self.api_secret) self.request_client = RequestClient(api_key=self.api_key, secret_key=self.api_secret)
def __init__(self): self.price = [] self.moving_avg_12 = 0 self.moving_avg_26 = 0 self.request_client = RequestClient( api_key= "cGBSO4BJK7Mmlhxnp4wUAI56wgNGZH6DrZLOzd8i1rM52EExhhgbedSxq6gqy4Sh", secret_key="")
def __init__(self): super().__init__() self.setupUi(self) self.keys = keys() self.request_client = RequestClient( api_key=self.keys.get_key(), secret_key=self.keys.get_secret_key()) self.init_variable() self.main()
def get_account_info(): try: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.get_account_information() return result except Exception as e: print(e) time.sleep(1) return None
def set_leverage(symbol, leverage): try: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.change_initial_leverage(symbol=symbol, leverage=leverage) return True except Exception as e: print(e) time.sleep(1) return False
def main(): #twitter setup lastDate = datetime.now() bearer_token = secrets.bearer_token API_key = secrets.API_key API_secret_key = secrets.API_secret_key #Elon musk twitter url url = "https://api.twitter.com/2/users/44196397/tweets" headers = create_headers(bearer_token) params = get_params() bought = False while not bought: try: json_response = connect_to_endpoint(url, headers, params) #get latest tweets tweets = json_response['data'] print("Search: ") for tweet in tweets: tweetDate = datetime.strptime( tweet['created_at'][:-1], '%Y-%m-%dT%H:%M:%S.%f') #get the time the tweet was posted tweetContent = tweet['text'].lower() splitTweetContent = tweetContent.split( ) #split tweet into words for word in splitTweetContent: #iterate through each word in the tweet if word == "doge": bought = True cryptoMessage = "Doge found in Elon's tweet: " + tweet[ 'text'] #generate crypto found message print(cryptoMessage) #Remember, that this is posting order on your binance Futures account and will take the multiplier, for example x25, that you have on doge. request_client = RequestClient( api_key=secrets.API_key_binance, secret_key=secrets.API_secret_key_binance, url='https://fapi.binance.com') result = request_client.post_order( symbol="DOGEUSDT", side=OrderSide.BUY, ordertype=OrderType.MARKET, quantity=6100) requests.post(url) break if bought: break print("Waiting 2 minutes") time.sleep(60) print("Waiting 60 seconds") time.sleep(60) except: print("Error")
def __init__(self) : super().__init__() self.setupUi(self) self.api_key = keys() self.request_client = RequestClient(api_key=self.api_key.api_key(), secret_key=self.api_key.secret_key()) # self.File_class = File_class('2020_05') self.init_vars() self.init_status_bools() self.init_signals_bools() self.init_update_threads() self.init_trade_threads()
def Post_BUY(): request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) quant = quantity price_diff = price_difference message = bot.aggTrade(symbol='BTCUSDT', limit=1) a = round(float(message[0]['p'])) buy = a + price_diff result = request_client.post_order(symbol="BTCUSDT", side=OrderSide.BUY, ordertype=OrderType.STOP_MARKET, quantity=quant, stopPrice=buy) buyId = result.orderId price = result.stopPrice return result, buyId, price
def thread_run(): global current_price request_client = RequestClient( api_key= "cGBSO4BJK7Mmlhxnp4wUAI56wgNGZH6DrZLOzd8i1rM52EExhhgbedSxq6gqy4Sh", secret_key="") result = request_client.get_mark_price(symbol="BTCUSDT") print(result.markPrice) current_price = result.markPrice threading.Timer(0.3, thread_run).start()
def get_position(): try: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.get_position() # PrintBasic.print_obj(result) return result except Exception as e: print(e) time.sleep(1) return None
def get_server_time(): try: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.get_servertime() return result["serverTime"] except Exception as e: print(e) time.sleep(1) return None
def crawlCandle(self, endTime: int, limit: int, interval: CandlestickInterval) -> pd.DataFrame: """ 단일 페이지를 바이낸스에서 크롤링한다. :param endTime: timestamp milli로 된 맨 마지막 시간 :param limit: 캔들 수 :param interval: 캔들간 간격 :return: 페이 """ request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result: [Candlestick] = request_client.get_candlestick_data(symbol="BTCUSDT", interval=interval, startTime=None, endTime=endTime, limit=limit) df = pd.DataFrame([vars(s) for s in result]) return df
class MACD_RSI_machine(): def __init__(self): self.price = [] self.moving_avg_12 = 0 self.moving_avg_26 = 0 self.request_client = RequestClient( api_key= "cGBSO4BJK7Mmlhxnp4wUAI56wgNGZH6DrZLOzd8i1rM52EExhhgbedSxq6gqy4Sh", secret_key="") def thread_run(self): self.run() threading.Timer(0.3, self.thread_run).start() def run(self): serverTime = self.request_client.get_servertime() #print("server time: ", datetime.fromtimestamp(serverTime / 1000)) server_obj = datetime.fromtimestamp((serverTime / 1000)) pTime = server_obj - timedelta(days=2) #print("one day ago : ", pTime) sticks = self.request_client.get_candlestick_data( symbol="BTCUSDT", interval=CandlestickInterval.MIN15, startTime=pTime, endTime=serverTime, limit=60) #print("======= Kline/Candlestick Data =======") # PrintMix.print_data(type(result)) for stick in sticks: self.price.append(float(stick.close)) _time = datetime.fromtimestamp(stick.closeTime / 1000) #print(f'{_time} : {stick.close}') #print("======================================") self.moving_avg_12 = sum(self.price[-12:]) / 12 self.moving_avg_26 = sum(self.price[-26:]) / 26 close_price_list = [] close_price_list_nparr = [] for a in self.price[-14:]: close_price_list.append(a) close_price_list_nparr = np.array(close_price_list, dtype='f8') rsi14 = ta.RSI(close_price_list_nparr, timeperiod=14) print( f' avg12 : {self.moving_avg_12} avg26 : {self.moving_avg_26} rsi14 : {rsi14}' ) print(len(self.price))
def on_status(self, status): if from_creator(status): tweet = status.text.lower() if "doge" in tweet: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.post_order(symbol="DOGEUSDT", side=OrderSide.BUY, ordertype=OrderType.MARKET, quantity=1000) print("Elon Musk just tweeted about DOGE!!") print("Rushing to buy a bag od doggies") PrintBasic.print_obj(result) return True return True
def __init__(self, settings, logger, on_tick_callback=None): super().__init__(settings, logger, on_tick_callback) self.symbol = settings.SYMBOL self.client = RequestClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.ws = SubscriptionClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.orders = {} self.positions = {} self.candles: List[Candlestick] = [] self.last = 0 self.open = False self.listen_key = "" self.init()
def printCandle(): request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result: [Candlestick] = request_client.get_candlestick_data( symbol="BTCUSDT", interval=CandlestickInterval.MIN1, startTime=None, endTime=None, limit=500) # np = numpy.vectorize(result) # print(np) # df = pandas.DataFrame(data=np, columns=['startTime', ]) # print(df) df = pandas.DataFrame([vars(s) for s in result]) print(df) print(df['openTime']) df['openTime'] = [ datetime.fromtimestamp(x // 1000.0) for x in df['openTime'] ] df['closeTime'] = [ datetime.fromtimestamp(x // 1000.0) for x in df['closeTime'] ] df['close'] = df['close'].astype(float) df['open'] = df['open'].astype(float) df['high'] = df['high'].astype(float) df['low'] = df['low'].astype(float) print(df) close = np.array(df['close']) print(close) df['sma5'] = talib.SMA(close, 5) df['sma20'] = talib.SMA(close, 20) df['sma120'] = talib.SMA(close, 120) df['ema12'] = talib.EMA(close, 12) df['ema26'] = talib.EMA(close, 26) df['rsi14'] = talib.RSI(close, 14) macd, macdsignal, macdhist = talib.MACD(close, 12, 26, 9) df['macd'] = macd print(df) df.to_excel("output.xlsx") printDataAsGraph(df.tail(90)) executeBacktest(df)
def order_stop(user_info): """ user_info:api_lable, tg_id, b_api_key, b_secret_key, tg_token 停止订单推送 """ # Start user data stream request_client = RequestClient(api_key=user_info[2], secret_key=user_info[3]) listen_key = request_client.start_user_data_stream() print("listenKey: ", listen_key) # Keep user data stream # result = request_client.keep_user_data_stream() # print("Result: ", result) # Close user data stream result = request_client.close_user_data_stream() print("**=="*90) print("Result: ", result)
def __init__(self, settings, logger, on_tick_callback=None): super().__init__(settings, logger, on_tick_callback) self.symbol: str = settings.SYMBOL self.client = RequestClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.ws = SubscriptionClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) # for binance the key is the internal id (not the exchange id) cause we can't update order but have to cancel and reopen with same id. # that leads to different exchange id, but we need to know its the same. self.orders = {} self.positions = {} self.symbol_object: Symbol = None self.candles: List[Candlestick] = [] self.last = 0 self.open = False self.listen_key = "" self.lastUserDataKeep = None self.wantedResponses = 0 # needed to wait for realtime self.init()
def get_client(strategy): k = strategy.api_key + strategy.api_secret client = clients.get(k) if client: return client else: with lock: client = RequestClient(api_key=strategy.api_key, secret_key=strategy.api_secret, url=binance_url) clients[k] = client return client
def maxWithdrawAmount(): request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.get_account_information() print("canDeposit: ", result.canDeposit) print("canWithdraw: ", result.canWithdraw) print("feeTier: ", result.feeTier) print("maxWithdrawAmount: ", result.maxWithdrawAmount) print("totalInitialMargin: ", result.totalInitialMargin) print("totalMaintMargin: ", result.totalMaintMargin) print("totalMarginBalance: ", result.totalMarginBalance) print("totalOpenOrderInitialMargin: ", result.totalOpenOrderInitialMargin) print("totalPositionInitialMargin: ", result.totalPositionInitialMargin) print("totalUnrealizedProfit: ", result.totalUnrealizedProfit) print("totalWalletBalance: ", result.totalWalletBalance) print("updateTime: ", result.updateTime) print("=== Assets ===") PrintMix.print_data(result.assets) print("==============") print("=== Positions ===") PrintMix.print_data(result.positions) print("==============") return result.maxWithdrawAmount, result.totalMarginBalance
def get_window(symbol): print('getting', symbol, 'dataframe') try: request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) result = request_client.get_candlestick_data(symbol=symbol, interval=CandlestickInterval.MIN15, startTime=None, endTime=None, limit=400) df = pd.DataFrame(data=result, columns=['time', 'O', 'H', 'L', 'C', 'vol', 'close_time', 'qa_volume', 'nb_trades', 'tba_valume', 'tqa_valume', 'ignore']) # print(df[['time','close_time','O',"C"]]) df[symbol] = df['O'].astype(float) df['time'] = df['time'].astype(int) df = df[['time', symbol]] return df except Exception as e: print(e) time.sleep(1) return None
def __init__(self, settings, logger, on_tick_callback=None): super().__init__(settings, logger, on_tick_callback) self.symbol: str = settings.SYMBOL self.client = RequestClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.ws = BinanceWebsocket(wsURL="wss://fstream.binance.com/ws", api_key=settings.API_KEY, api_secret=settings.API_SECRET, logger=logger, callback=self.callback) # for binance the key is the internal id (not the exchange id) cause we can't update order but have to cancel # and reopen with same id. that leads to different exchange id, but we need to know its the same. self.orders = {} self.positions = {} self.symbol_object: Symbol = None self.candles: List[Candlestick] = [] self.last = 0 self.listen_key = "" self.lastUserDataKeep = None self.wantedResponses = 0 # needed to wait for realtime if self.is_open(): self.init()
def record_loop(): global request_client backtest.init_strategy() current = 0 while (True): try: dataNow = datetime.now().minute # check the server connection if dataNow != current: if (dataNow % 5) == 0: result = backtest.get_servertime() if result != 0: current = dataNow backtest.positionSize = 0 backtest.get_open_positions(backtest.coin) backtest.get_open_orders() if backtest.positionSize == 0: backtest.buyStatus = 0 backtest.process_Price() print("INFO: Bot -> ON ") else: try: request_client = RequestClient( api_key=g_api_key, secret_key=g_secret_key, url='https://testnet.binancefuture.com/') except Exception as e: print(e) print("ERROR: restarting client") else: print("INFO: Cient restarted") except Exception as e: print(e)
def check_best_trade(interval=Intervals.DAY): request_client = RequestClient(api_key=API_KEY, secret_key=SECRET_KEY) # Request info of all symbols to retrieve precision response = requests.get(BINANCE_FUTURES_BASE_URL + BINANCE_FUTURES_EXCHANGE_INFO_ENDPOINT) exchange_info = response.json() price_precision = 0 best_wicks = [] print('Number of pairs to check approx: ', len(exchange_info['symbols'])) for item in exchange_info['symbols']: if (not item['contractType'] == 'PERPETUAL'): continue print('\t * Checking: {}'.format(item['symbol'])) candles = get_last_binance_candles(item['symbol'], interval, Markets.FUTURES) if (not len(candles) > 1): continue current_candle = candles[1] cc_open = float(current_candle[1]) cc_high = float(current_candle[2]) cc_low = float(current_candle[3]) cc_close = float(current_candle[4]) # Candle is green if (cc_open < cc_close): diff = cc_high - cc_close cc_wick = round((diff / cc_close) * 100, 2) best_wicks.append({'wick': cc_wick, 'symbol': item['symbol']}) #else: # Candle is red result = sorted(best_wicks, key=lambda k: k['wick'], reverse=True) print(white.bold('Best wicks to trade found are:')) for item in result[0:10]: print( green.bold('\t{} -> {} % wick.'.format(item['symbol'], item['wick'])))
def __init__(self, api_key=None, secret_key=None, init_balance=0, leverage=1): self.api_key = api_key self.secret_key = secret_key # self.init_balance=init_balance self.leverage = leverage logger.warn('now leverage:', self.leverage) request_client = RequestClient(api_key=g_api_key, secret_key=g_secret_key) self.request_client = request_client # 初始化变量 None? self.get_account_information_result = 0 self.get_position_result = 0 self.get_symbol_price_ticker_result = 0 self.get_candlestick_data_result = 0 self.get_symbol_orderbook_ticker_result = 0 self.position_info_list = [] self.depth_ticker_dict = {} if init_balance != 0: self.origin_balance = init_balance else: self.origin_balance = 0 self.margin_balance = 0.0000001 self.total_margin_ratio = 0 self.old_total_balance = 0 # 初始化交易对基础信息 self.exchange_info = {} self.io_get_exchange_info() self.position_info_long = {} self.position_info_short = {}
class Futures(BinanceAPI): markPrice = None def __init__(self, requests_only=False): super().__init__() if not requests_only: self.sub_client = SubscriptionClient(api_key=self.api_key, secret_key=self.api_secret) self.request_client = RequestClient(api_key=self.api_key, secret_key=self.api_secret) def callback(self, data_type: 'SubscribeMessageType', event: 'any'): if data_type == SubscribeMessageType.RESPONSE: print("Event ID: ", event) elif data_type == SubscribeMessageType.PAYLOAD: self.markPrice = event.markPrice else: print("Unknown Data:") def error(self, e: 'BinanceApiException'): return e.error_code + e.error_message def start_listening(self, ticker="btcusdt"): self.sub_client.subscribe_mark_price_event(ticker, self.callback, self.error) def stop_listening(self): self.sub_client.unsubscribe_all() def get_price(self, ticker="btcusdt"): try: return self.request_client.get_mark_price(symbol=ticker).markPrice except BinanceApiException as e: return "Invalid symbol." if e.error_code == "ExecuteError" else e.error_message
class BinanceInterface(ExchangeInterface): def __init__(self, settings, logger, on_tick_callback=None): super().__init__(settings, logger, on_tick_callback) self.symbol = settings.SYMBOL self.client = RequestClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.ws = SubscriptionClient(api_key=settings.API_KEY, secret_key=settings.API_SECRET) self.orders = {} self.positions = {} self.candles: List[Candlestick] = [] self.last = 0 self.open = False self.listen_key = "" self.init() def init(self): self.logger.info("loading market data. this may take a moment") self.initOrders() self.initPositions() self.logger.info("got all data. subscribing to live updates.") self.listen_key = self.client.start_user_data_stream() self.ws.subscribe_user_data_event(self.listen_key, self.callback, self.error) subbarsIntervall = CandlestickInterval.MIN1 if self.settings.MINUTES_PER_BAR <= 60 else CandlestickInterval.HOUR1 self.ws.subscribe_candlestick_event(self.symbol, subbarsIntervall, self.callback, self.error) self.open = True self.lastUserDataKeep = time.time() self.logger.info("ready to go") def callback(self, data_type: 'SubscribeMessageType', event: 'any'): gotTick = False # refresh userdata every 15 min if self.lastUserDataKeep < time.time() - 15 * 60: self.lastUserDataKeep = time.time() self.client.keep_user_data_stream() # TODO: implement! (update bars, orders and account) if data_type == SubscribeMessageType.RESPONSE: pass # what to do herE? elif data_type == SubscribeMessageType.PAYLOAD: if event.eventType == "kline": # {'eventType': 'kline', 'eventTime': 1587064627164, 'symbol': 'BTCUSDT', # 'data': <binance_f.model.candlestickevent.Candlestick object at 0x0000016B89856760>} if event.symbol == self.symbol: candle: Candlestick = event.data if len(self.candles) > 0: if candle.startTime <= self.candles[ 0].startTime and candle.startTime > self.candles[ -1].startTime: # somewhere inbetween to replace for idx in range(0, len(self.candles)): if candle.startTime == self.candles[ idx].startTime: self.candles[idx] = candle break elif candle.startTime > self.candles[0].startTime: self.candles.insert(0, candle) gotTick = True else: self.candles.append(candle) gotTick = True elif (event.eventType == "ACCOUNT_UPDATE"): # {'eventType': 'ACCOUNT_UPDATE', 'eventTime': 1587063874367, 'transactionTime': 1587063874365, # 'balances': [<binance_f.model.accountupdate.Balance object at 0x000001FAF470E100>,...], # 'positions': [<binance_f.model.accountupdate.Position object at 0x000001FAF470E1C0>...]} usdBalance = 0 for b in event.balances: bal: Balance = b if bal.asset == "USDT": usdBalance = bal.walletBalance for p in event.positions: pos: Position = p if pos.symbol not in self.positions.keys(): self.positions[pos.symbol] = AccountPosition( pos.symbol, avgEntryPrice=float(pos.entryPrice), quantity=float(pos.amount), walletBalance=usdBalance if "USDT" in pos.symbol else 0) else: accountPos = self.positions[pos.symbol] accountPos.quantity = float(pos.amount) accountPos.avgEntryPrice = float(pos.entryPrice) if "USDT" in pos.symbol: accountPos.walletBalance = usdBalance elif (event.eventType == "ORDER_TRADE_UPDATE"): # {'eventType': 'ORDER_TRADE_UPDATE', 'eventTime': 1587063513592, 'transactionTime': 1587063513589, # 'symbol': 'BTCUSDT', 'clientOrderId': 'web_ybDNrTjCi765K3AvOMRK', 'side': 'BUY', 'type': 'LIMIT', # 'timeInForce': 'GTC', 'origQty': 0.01, 'price': 6901.0, 'avgPrice': 0.0, 'stopPrice': 0.0, # 'executionType': 'NEW', 'orderStatus': 'NEW', 'orderId': 2705199704, 'lastFilledQty': 0.0, # 'cumulativeFilledQty': 0.0, 'lastFilledPrice': 0.0, 'commissionAsset': None, 'commissionAmount': None, # 'orderTradeTime': 1587063513589, 'tradeID': 0, 'bidsNotional': 138.81, 'asksNotional': 0.0, # 'isMarkerSide': False, 'isReduceOnly': False, 'workingType': 'CONTRACT_PRICE'} sideMulti = 1 if event.side == 'BUY' else -1 order: Order = Order(orderId=event.clientOrderId, stop=event.stopPrice, limit=event.price, amount=event.origQty * sideMulti) order.exchange_id = event.orderId #FIXME: how do i know stop triggered on binance? #order.stop_triggered = order.executed_amount = event.cumulativeFilledQty * sideMulti order.executed_price = event.avgPrice order.tstamp = event.transactionTime order.execution_tstamp = event.orderTradeTime prev: Order = self.orders[ order. exchange_id] if order.exchange_id in self.orders.keys( ) else None if prev is not None: if prev.tstamp > order.tstamp or abs( prev.executed_amount) > abs(order.executed_amount): # already got newer information, probably the info of the stop order getting # triggered, when i already got the info about execution self.logger.info("ignoring delayed update for %s " % (prev.id)) if order.stop_price is None: order.stop_price = prev.stop_price if order.limit_price is None: order.limit_price = prev.limit_price prev = order if not prev.active and prev.execution_tstamp == 0: prev.execution_tstamp = datetime.utcnow().timestamp() self.orders[order.exchange_id] = prev self.logger.info("received order update: %s" % (str(order))) else: self.logger.warn("Unknown Data in websocket callback") if gotTick and self.on_tick_callback is not None: self.on_tick_callback() # got something new def error(self, e: 'BinanceApiException'): self.exit() self.logger.error(e.error_code + e.error_message) def initOrders(self): apiOrders = self.client.get_open_orders() for o in apiOrders: order = self.convertOrder(o) if order.active: self.orders[order.exchange_id] = order def convertOrder(self, apiOrder: binance_f.model.Order) -> Order: direction = 1 if apiOrder.side == OrderSide.BUY else -1 order = Order(orderId=apiOrder.clientOrderId, amount=apiOrder.origQty * direction, limit=apiOrder.price, stop=apiOrder.stopPrice) order.executed_amount = apiOrder.executedQty * direction order.executed_price = apiOrder.avgPrice order.active = apiOrder.status in ["NEW", "PARTIALLY_FILLED"] order.exchange_id = apiOrder.orderId return order def initPositions(self): balance = self.client.get_balance() usdBalance = 0 for bal in balance: if bal.asset == "USDT": usdBalance = bal.balance api_positions = self.client.get_position() self.positions[self.symbol] = AccountPosition(self.symbol, 0, 0, 0) if api_positions is not None: for pos in api_positions: self.positions[pos.symbol] = AccountPosition( pos.symbol, avgEntryPrice=pos.entryPrice, quantity=pos.positionAmt, walletBalance=usdBalance if "USDT" in pos.symbol else 0) self.logger.info("starting with %.2f in wallet and pos %.2f @ %.2f" % (self.positions[self.symbol].walletBalance, self.positions[self.symbol].quantity, self.positions[self.symbol].avgEntryPrice)) def exit(self): self.ws.unsubscribe_all() self.open = False def internal_cancel_order(self, order: Order): if order.exchange_id in self.orders.keys(): self.orders[order.exchange_id].active = False self.client.cancel_order(symbol=self.symbol, origClientOrderId=order.id) def internal_send_order(self, order: Order): order_type = OrderType.MARKET if order.limit_price is not None: if order.stop_price is not None: order_type = OrderType.STOP else: order_type = OrderType.LIMIT else: order_type = OrderType.STOP_MARKET resultOrder: binance_f.model.Order = self.client.post_order( symbol=self.symbol, side=OrderSide.BUY if order.amount > 0 else OrderSide.SELL, ordertype=order_type, timeInForce=TimeInForce.GTC, quantity=abs(order.amount), price=order.limit_price, stopPrice=order.stop_price, newClientOrderId=order.id) order.exchange_id = resultOrder.orderId def internal_update_order(self, order: Order): self.cancel_order(order) # stupid binance can't update orders self.send_order(order) def get_orders(self) -> List[Order]: return list(self.orders.values()) def get_bars(self, timeframe_minutes, start_offset_minutes) -> List[Bar]: tf = CandlestickInterval.MIN1 if timeframe_minutes <= 60 else CandlestickInterval.HOUR1 bars = self.client.get_candlestick_data(symbol=self.symbol, interval=tf, limit=1000) return self._aggregate_bars(reversed(bars), timeframe_minutes, start_offset_minutes) def recent_bars(self, timeframe_minutes, start_offset_minutes) -> List[Bar]: return self._aggregate_bars(self.bars, timeframe_minutes, start_offset_minutes) def _aggregate_bars(self, bars, timeframe_minutes, start_offset_minutes) -> List[Bar]: subbars = [] for b in bars: subbars.append(self.convertBar(b)) return process_low_tf_bars(subbars, timeframe_minutes, start_offset_minutes) def convertBar(self, apiBar: binance_f.model.candlestick.Candlestick): return Bar(tstamp=apiBar.openTime / 1000, open=apiBar.open, high=apiBar.high, low=apiBar.low, close=apiBar.close, volume=apiBar.volume) def get_instrument(self, symbol=None): if symbol is None: symbol = self.symbol instr: binance_f.model.exchangeinformation.ExchangeInformation = self.client.get_exchange_information( ) for symb in instr.symbols: if symb.symbol == symbol: baseLength = len(symb.baseAsset) lotSize = 0 tickSize = 0 for filter in symb.filters: if filter['filterType'] == 'LOT_SIZE': lotSize = filter['stepSize'] if filter['filterType'] == 'PRICE_FILTER': tickSize = filter['tickSize'] return Symbol( symbol=symb.symbol, isInverse=symb.baseAsset != symb.symbol[:baseLength], lotSize=lotSize, tickSize=tickSize, makerFee=0.02, takerFee=0.04) return None def get_position(self, symbol=None): if symbol is None: symbol = self.symbol return self.positions[symbol] if symbol in self.positions.keys( ) else None def is_open(self): return self.open def check_market_open(self): return self.open # TODO: is that the best we can do? def update_account(self, account: Account): pass