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
