def read_bitmex(test, api_key, api_secret, symbol,
binSize): # test = True switches on TESTNET
client = bitmex.bitmex(test=test, api_key=api_key, api_secret=api_secret)
client = bitmex.bitmex()
df = client.Trade.Trade_getBucketed(symbol=symbol,
binSize=binSize,
count=500,
reverse=True).result()
df = pd.DataFrame(df[0])
# df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume', 'turnover', 'trades']]
df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']]
# df = df.rename(columns={'timestamp':'DATETIME', 'open':'OPEN', 'high':'HIGH', 'low':'LOW', 'close':'CLOSE', 'volume':'VOLUME', 'turnover':'TURNOVER', 'trades':'TRADES'})
df = df.rename(
columns={
'timestamp': 'DATETIME',
'open': 'OPEN',
'high': 'HIGH',
'low': 'LOW',
'close': 'CLOSE',
'volume': 'VOLUME'
})
df.set_index('DATETIME', inplace=True)
df.index = pd.to_datetime(df.index, format='%Y-%m-%dT%H:%M:%S')
df.sort_index(inplace=True, ascending=True)
return df
def create_gateway_obj(self, exchange, setting):
"""
创建gateway对象
:param exchange: 交易所
:param setting: 配置信息
:return: 交易所对象
"""
if "BITMEX" == exchange:
# _bitmex 避免和 bitmex 模块重名，所以加下划线区分
_bitmex = ccxt.bitmex(setting)
# 设置为测试服务器
_bitmex.urls["api"] = _bitmex.urls["test"]
_bitmex.urls["www"] = _bitmex.urls["test"]
# 引入bitmex官方的对象
_bitmex.client = bitmex.bitmex(test=True, api_key=setting["apiKey"], api_secret=setting["secret"])
return _bitmex
elif "BITMEX_REAL" == exchange:
# bitmex实盘对象
# _bitmex 避免和 bitmex 模块重名，所以加下划线区分
_bitmex = ccxt.bitmex(setting)
# 引入bitmex官方的对象
_bitmex.client = bitmex.bitmex(test=False, api_key=setting["apiKey"], api_secret=setting["secret"])
return _bitmex
elif "OKEX" == exchange:
obj_okex = ccxt.okex3()
return obj_okex
else:
pass
def __init__(self, api_key, api_secret, main_net=False):
logging.info(f"Initialize client. Main net: {main_net}")
if main_net:
self.client = bitmex.bitmex(test=False,
api_key=api_key,
api_secret=api_secret)
# self.ws = BitMEXWebsocket(endpoint="https://www.bitmex.com/api/v2", symbol="XBTUSD", api_key=api_key,
# api_secret=api_secret)
else:
self.client = bitmex.bitmex(test=True,
api_key=api_key,
api_secret=api_secret)
def set_network(self, args):
if args.live:
self.CONFIG_VARS['testnet'] = False
self.client = bitmex.bitmex(
test=False,
api_key=self.CONFIG_VARS['REAL_API_KEY'],
api_secret=self.CONFIG_VARS['REAL_API_SECRET'])
if args.test:
self.CONFIG_VARS['testnet'] = True
self.client = bitmex.bitmex(
test=True,
api_key=self.CONFIG_VARS['TEST_API_KEY'],
api_secret=self.CONFIG_VARS['TEST_API_SECRET'])
def __init__(self, do_init_symbols=False, do_fill_history=False):
super().__init__(name='Feeder', daemon=True)
self.endpoint = "https://testnet.bitmex.com/api/v1" if config.TEST_NET else "https://www.bitmex.com/api/v1"
self.ws = BitMexWS(endpoint=self.endpoint,
api_key=None,
api_secret=None)
self.api = bitmex.bitmex(test=config.TEST_NET)
self.api_auth = bitmex.bitmex(test=config.TEST_NET,
api_key=config.EXCHANGE_PUBLIC_KEY,
api_secret=config.EXCHANGE_SECRET_KEY)
self.do_init_symbols = do_init_symbols
self.do_fill_history = do_fill_history
self.logger = logging.getLogger(self.__class__.__name__)
self.is_working = False
def __init__(self, trade, leverage, tp, test, ord_type):
self.bitmex_api_key = Config.get('Bitmex', 'api_key')
self.bitmex_api_secret = Config.get('Bitmex', 'api_secret')
self.bitmex_api_key_t = Config.get('Bitmex-Testnet', 'api_key')
self.bitmex_api_secret_t = Config.get('Bitmex-Testnet', 'api_secret')
self.slack_api = Config.get("Slack", 'api_key')
self.trade = trade
self.long = False
self.type = 'GoodTillCancel'
self.ord_type = ord_type
self.short = False
print('sending trades? ' + str(self.trade))
self.leverage = leverage
self.take_profit = tp
self.stop_loss = 0.1 # 10%
self.slips = []
if test and 1 == 2:
self.auth_client_bitmex = bitmex.bitmex(
test=True,
api_key=self.bitmex_api_key_t,
api_secret=self.bitmex_api_secret_t)
print('testnet')
elif 1 == 2:
self.auth_client_bitmex = bitmex.bitmex(
test=False,
api_key=self.bitmex_api_key,
api_secret=self.bitmex_api_secret)
print('LIVE')
try:
self.auth_client_bitmex.Position.Position_updateLeverage(
symbol='XBTUSD', leverage=leverage).result()
self.last_bal = float(
self.auth_client_bitmex.User.User_getMargin().result()[0]
['marginBalance'] / 100000000)
except:
pass
self.channel = 'tradeupdates'
self.channel_trades = 'trades'
self.client = slack.WebClient(self.slack_api, timeout=30)
self.trade_template = {
'signal_price': 0.0,
'fill_price': 0.0,
'quantity': 0.0,
'leverage': 1,
'side': '',
'timestamp': ''
}
def __init__(self, apiKey, apiSecret, pairs, name):
super().__init__(apiKey, apiSecret, pairs, name)
self.pairs = list(
map(
lambda pair: self.translate(pair)
if pair != self.translate(pair) else self.logger.debug(
f"Can't translate word {pair} in {self.exchange_name}"),
self.pairs))
self.pairs = list(filter(None, self.pairs))
self.connection = bitmex.bitmex(api_key=apiKey, api_secret=apiSecret)
self.socket = {}
# self.firts_copy_flag = True
self.balance_updated = False
self.socket['XBTUSD'] = BitMEXWebsocket(
endpoint=self.ENDPOINT,
symbol='XBTUSD',
api_key=self.api['key'],
api_secret=self.api['secret'],
on_balance_update=self.on_balance_update)
for pair in self.pairs:
if pair == 'XBTUSD':
continue
self.socket[pair] = BitMEXWebsocket(endpoint=self.ENDPOINT,
symbol=pair,
api_key=self.api['key'],
api_secret=self.api['secret'])
def startAdapter(self):
# set info for position managers
for i, pos in self.tradeTickerPositionMap.items():
pos.setBaseCashValue(self.cashBaseValue)
# rest api
self.restAPI = bitmex.bitmex(test=self.isTestSystem, api_key=self._api_key, api_secret=self._secret_key)
time.sleep(1)
"""连接服务器"""
# adapters.websocket.enableTrace(False)
# zzdai? 针对一个ticker,后期优化
self._ws_url = self.getSubscribeUrls(self.workingTickers[0])
self._ws = adapters.websocket.WebSocketApp(self._ws_url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open,
header=self.getAuth())
self.thread = Thread(target=self._ws.run_forever)
self.thread.start()
conn_timeout = 5
while not self._ws.sock or not self._ws.sock.connected and conn_timeout:
time.sleep(1)
conn_timeout -= 1
if not conn_timeout:
print("[ERR]: ", adapters.coinUtilities.getCurrentTimeString(), \
"link to", self.getAPI_name(), "failed", file=sys.stderr)
# query account info
self.query_future_userinfo()
def Conn_REST_BitMEX(StartTime):
now = datetime.now()
before_now = now
if before_now.minute % 5 == 0:
Minutes = before_now.minute
else:
Minutes = before_now.minute - (before_now.minute % 5)
client = bitmex(test=False, api_key=None, api_secret=None)
StartTime = from_SGT_to_UTC(StartTime)
EndTime = from_SGT_to_UTC(
datetime(before_now.year, before_now.month, before_now.day,
before_now.hour, Minutes, 0))
trades = client.Trade.Trade_getBucketed(binSize='5m',
partial=True,
symbol='XBTUSD',
count=200,
startTime=StartTime,
endTime=EndTime).result()[0]
i = 0
for element in trades:
ToDB = {}
ToDB['time_period_end'] = from_UTC_to_SGT(element['timestamp'])
ToDB['price_open'] = element['open']
ToDB['price_high'] = element['high']
ToDB['price_low'] = element['low']
ToDB['price_close'] = element['close']
ToDB['volume'] = element['volume']
export_to_MySQL(ToDB)
i = i + 1
def get_data(start_time: datetime = datetime(2019, 6, 27),
symbol: str = "XBTUSD",
delay: float = 0.2):
clinet = bitmex.bitmex(test=True, api_key=API_KEY, api_secret=API_SECRET)
trades = []
count = 500
start = 0
while True:
try:
query = clinet.Trade.Trade_get(symbol=symbol,
startTime=start_time,
start=start,
count=count,
reverse=True)
response = query.result()[0]
except Exception as e:
logging.error(e)
continue
trades.extend(response)
if len(response) < count:
break
start += count
sleep(delay)
return trades
def __init__(self, pipe_price, pipe_order, TestServer, api_key,
api_secret):
self.__pipe_price = pipe_price
self.__pipe_order = pipe_order
self.client = bitmex.bitmex(test=TestServer,
api_key=api_key,
api_secret=api_secret)
def tmp(self):
# print(self.get_balance(quotes_df))
# random.seed(3) # remove when done debugging. <------------------------------------
# current_time = quotes_df.index.tolist()[0] # extrapolate latest time
# random_int = random.randint(0,1)
# action_list = ['Buy','Sell']
# random_action = action_list[random_int]
# logger.info("Random action: {}".format(random_action))
# clOrdLinkID = str(uuid.uuid4()) # generate unique ID
logger.info("%%%%%%%%%")
# # set main order
# order = self.exchange.send_smart_order(side=random_action, orderQty=settings.ORDER_QUANTITY)
self.bitmex = bitmex.bitmex(test=settings.USE_TESTNET,
api_key=settings.API_KEY_TEST,
api_secret=settings.API_SECRET_TEST)
logger.info("Connected to TESTNET")
# order = self.bitmex.Order.Order_new(symbol=settings.SYMBOL, side='Buy', orderQty=100, ordType='Market').result()
order = self.bitmex.Order.Order_new(
symbol=settings.SYMBOL,
side='Buy',
orderQty=100,
ordType='Limit',
execInst='ParticipateDoNotInitiate',
price='8700').result()
order_id = order[0]['orderID']
# logger.info(order)
# logger.info('%%%$$$$$')
logger.info(self.exchange.cancel_order_by_id(order_id))
def __init__(self, account):
try:
self.client = bitmex.bitmex(api_key=account.api_key,
api_secret=account.api_secret)
except Exception as e:
print(e)
raise APIException(detail='bitmex api not available')
def Conn_REST_BitMEX(StartTime):
try:
client = bitmex(test=False, api_key=None,
api_secret=None) ### Risk of 502 Error : Bad Gateway
StartTime = from_SGT_to_UTC(StartTime)
print(StartTime)
trades = client.Trade.Trade_getBucketed(
binSize='5m',
partial=True,
symbol='XBTUSD',
count=2,
startTime=StartTime).result()[0]
## Risk of 503 Error : Service Unavailable
i = 0
for element in trades:
ToDB = {}
ToDB['time_period_end'] = from_UTC_to_SGT(element['timestamp'])
ToDB['price_open'] = element['open']
ToDB['price_high'] = element['high']
ToDB['price_low'] = element['low']
ToDB['price_close'] = element['close']
ToDB['volume'] = element['volume']
print(i)
print(ToDB)
if i == 0:
#export_to_MongoDB_sub(ToDB)
export_to_MySQL(ToDB)
i = i + 1
except Exception as e:
print(e)
msg = "BitMEX server에서 Error가 발생하였습니다.\n" + str(e)
Telegram_Alert(msg)
def main():
client = bitmex.bitmex(test=False,
api_key=get_auth('APIKEY'),
api_secret=get_auth('SECRET'))
request_instrument(client, li=('highPrice', 'lowPrice', 'lastPrice'))
request_funding(client)
def __init__(self, apiconfpth=kfpth):
f = open(apiconfpth, 'r')
lines = f.readlines()
f.close()
apikey = lines[0].replace('\r', '').replace('\n', '')
secretkey = lines[1].replace('\r', '').replace('\n', '')
self.client = bitmex.bitmex(test=True,
api_key=apikey,
api_secret=secretkey)
# https://www.bitmex.com/realtime
# https://www.bitmex.com/api/v1
self.ws = BitMEXWebsocket(
endpoint="https://testnet.bitmex.com/realtime",
symbol="XBTUSD",
api_key=None,
api_secret=None)
self.logger = self.setup_logger()
self.logger.info("Instrument data: %s" % self.ws.get_instrument())
AlarmPrice.initAlarmObj(self.ws)
def get(request, order_id):
"""Show order info for an account"""
account_name = request.query_params.get('account')
try:
account = _get_account_(account_name)
except AccountNotFound as err:
return Response(
data={'error': str(err)},
status=status.HTTP_404_NOT_FOUND,
)
client = bitmex(
test=BITMEX_TEST_MODE,
api_key=account.api_key,
api_secret=account.api_secret,
)
filter_ = json.dumps({'orderID': order_id})
try:
result, _ = client.Order.Order_getOrders(filter=filter_).result()
except HTTPUnauthorized as err:
return Response(
data={'error': str(err)},
status=status.HTTP_401_UNAUTHORIZED,
)
if not result:
return Response(
data={
'error': f'Can not find any order with order id: {order_id!r} '
f'for the account name: {account.name!r}'
},
status=status.HTTP_404_NOT_FOUND,
)
return Response(result)
def __init__(self):
self.symbol = settings.SYMBOL
self.bitmex = bitmex.bitmex(api_key=settings.API_KEY,
api_secret=settings.API_SECRET,
test=False)
self.ws = BitMEXWebsocket()
self.ws.connect(settings.BASE_URL, self.symbol)
class BitmexClient:
api_key = '94IFRKCGQj_ViW4KLvCvQ1nO' # API KEY
api_secret = 'w9x9w_rYkgc-RPzbEjx1VyItYTUkhOs1pCfAZivRrNqJ-HD9' # SECRET API KEY
client = bitmex(test=False, api_key=api_key, api_secret=api_secret)
# Function returns array of records for specified symbol(e.g 'ICXBTC'), interval('1m', '5m', '1h', '1d')
# and desired "start day"(datetime(Y,M,D)). Array consists of below arrays
# [
# {
# "timestamp": "2020-05-27T13:34:46.996Z",
# "symbol": "string",
# "open": 0,
# "high": 0,
# "low": 0,
# "close": 0,
# "trades": 0,
# "volume": 0,
# "vwap": 0,
# "lastSize": 0,
# "turnover": 0,
# "homeNotional": 0,
# "foreignNotional": 0
# }
# ]
def get_historical_data_with_interval(self, symbol, interval, start):
now = datetime.now()
start = start.strftime("%d %b %Y %H:%M:%S")
data = \
self.client.Trade.Trade_getBucketed(symbol=symbol, binSize=interval, startTime=start, endTime=now).result()[0]
return data
def wrapper(instance, request, *args, **kwargs):
name = request.query_params.get('account')
account = get_object_or_404(Account.objects.all(), name=name)
instance.client = bitmex.bitmex(test=True,
api_key=account.api_key,
api_secret=account.api_secret)
instance.account = account
return func(instance, request, *args, **kwargs)
def amount_in_orders():
client = bitmex.bitmex(test=TESTNET_EXCHANGE,
api_key=BITMEX_API_KEY,
api_secret=BITMEX_API_SECRET)
result = client.Position.Position_get().result()
return float(result[0][0]['currentQty'])
def update_strategy(self, strategy):
self.strategy = strategy
if strategy.api_key and self.api_key != strategy.api_key:
self.api_key = strategy.api_key
self.api_secret = strategy.api_secret
self.client = bitmex.bitmex(test=False,
api_key=self.api_key,
api_secret=self.api_secret)
def __init__(self, symbol):
self.ctr = 0
self.symbol = symbol
#self.logger = self.setup_logger()
# hoang: wbFfEOkZqut7OG8rueCPTmEsCsYHyqxakxlg1dNoZbz7EJ6w
# hoang: ZJ7ZG0bDrem884wQkNnvv2PB
api_key = "ZJ7ZG0bDrem884wQkNnvv2PB" #"9FR7reF9F71NDZG_BDoMsfm9" # 8vXVw923QlDRoRtXSwvwbXlU
api_secret = "wbFfEOkZqut7OG8rueCPTmEsCsYHyqxakxlg1dNoZbz7EJ6w" #"TiXEEabXxJ_KX5ev_RoOnB-JVQqDdj4AAMJvRBXpPhtAKGVH" # nFZS4qiArohuyY_4J9oGBk49X2iL5LteAXCrHcHveF6j5Gwi
# Instantiating the WS will make it connect. Be sure to add your api_key/api_secret.
self.ws = BitMEXWebsocket(endpoint="https://www.bitmex.com/api/v1",
symbol=self.symbol,
api_key=api_key,
api_secret=api_secret)
self.ws.get_instrument()
#self.logger.info("Instrument data: %s" % self.ws.get_instrument())
self.client = bitmex.bitmex(test=False,
api_key=api_key,
api_secret=api_secret)
self.last_r = None
self.last_spread = None
#self.clean = False
self.tick = []
self.cur_volatility = None
self.act_volatility = None
self.streak = 0
self.prev_len = 0
self.cur_len = 0
self.idle = 0
self.first = True
self.sleep_ctr = 0
self.general_ctr = 0
exchange = ccxt.bitmex()
date_N_days_ago = (
datetime.datetime.now() -
datetime.timedelta(hours=2)).strftime("%Y-%m-%d %H:%M:%S")
since = time.mktime(
datetime.datetime.strptime(date_N_days_ago,
"%Y-%m-%d %H:%M:%S").timetuple()) * 1000
df = exchange.fetch_ohlcv('ETH/USD',
timeframe='1m',
since=since,
limit=500)
df = pd.DataFrame(df)
df.columns = ["Timestamp", "Open", "High", "Low", "tick", "Volume"]
self.df = pd.DataFrame({'tick': df.tick.values.tolist()})
#print (df.tail())
#print (self.df.tail())
# always fetch df using ccxt
# check number of pos: if len(pos) > 0 : self.first = False
logging.info("App Initiated!")
def post(request):
"""Create new order for an account"""
try:
account_name = request.query_params.get('account')
account = _get_account_(account_name)
except AccountNotFound as err:
return Response(
data={'error': str(err)},
status=status.HTTP_404_NOT_FOUND,
)
client = bitmex(
test=BITMEX_TEST_MODE,
api_key=account.api_key,
api_secret=account.api_secret,
)
try:
# FIXME: it always raises error:
# "Account has insufficient Available Balance"
result, _ = client.Order.Order_new(
symbol=request.data['symbol'],
orderQty=request.data['volume'],
side=request.data['side'],
ordType='Market',
).result()
except HTTPUnauthorized as err:
return Response(
data={'error': str(err)},
status=status.HTTP_401_UNAUTHORIZED,
)
except HTTPNotFound as err:
return Response(
data={'error': str(err)},
status=status.HTTP_404_NOT_FOUND,
)
except HTTPBadRequest as err:
return Response(
data={'error': str(err)},
status=status.HTTP_400_BAD_REQUEST,
)
except KeyError as err:
return Response(
data={'error': f'Missed mandatory field {err}'},
status=status.HTTP_400_BAD_REQUEST,
)
serializer = OrderSerializer(
data={
**request.data,
'order_id': result.get('orderID'),
'price': result.get('price'),
'account': account.id,
}
)
if serializer.is_valid():
serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def get_client(self):
if self.client is None:
account = self.get_account()
# default test=True. Можна добавити окремим полем в модель Account.
try:
self.client = bitmex.bitmex(api_key=account.api_key, api_secret=account.api_secret)
except Exception:
raise ValidationError('Failed to connect to BitMEX on account data.')
return self.client
def _fetch_raw_responses(self, date_list: list) -> list:
client = bitmex.bitmex(test=False,
api_key=self.api_key,
api_secret=self.api_secret)
raw_responses: list = list()
for timestamp in tqdm(date_list):
response = self._get_data_via_api_call(client, timestamp)
raw_responses.append(response)
return raw_responses
def __init__(self, test=True, **kwargs):
"""
added parameted for the client in bitmex
:param test:
"""
super().__init__(**kwargs)
self.client = bitmex.bitmex(test=test, api_key=self.apiKey, api_secret=self.apiSecret)
self.logger = logging.getLogger("Bitmex If")
self.logger.setLevel(logging.DEBUG)
def run_bot(key, secret, confidence, risk, reward):
# api_key = "-iXO_17idCPYYQgGsRtB7HfI"
# api_secret = "yod97ok0bHhrdumSb4XnF0KDAg1LH0QciHkVyHb3sF0z0Y8J"
client = bitmex.bitmex(test=True, api_key=api_key, api_secret=api_secret)
conn = sqlite3.connect("btc.db")
model = load("BTC_100m_forecast.joblib")
while True:
try:
position = get_position(client)
except (bravado.exception.HTTPServiceUnavailable):
time.sleep(5)
position = get_position(client)
data = pd.read_sql_query(
"SELECT * FROM book_imbalances_lag_10 ORDER BY time DESC LIMIT 501 ",
conn,
)[::-1].reset_index(drop=True).drop(columns=["index", "lag period"])
# Transform dataframe
transformed = data.copy()
history = 500
shifts = [x for x in list(range(1, history + 1))]
for shift in shifts:
transformed["t-oir-" +
str(shift)] = transformed["oir"].shift(shift)
transformed["t-voi-" +
str(shift)] = transformed["voi"].shift(shift)
transformed["t-tfi-" +
str(shift)] = transformed["tfi"].shift(shift)
transformed["t-midprice-" +
str(shift)] = transformed["midprice"].shift(shift)
transformed = transformed.dropna()
transformed = transformed.set_index("time").drop(
["midprice", "oir", "voi", "tfi"], axis=1)
prediction = model.predict(transformed)[0]
probs = model.predict_proba(transformed)[0][prediction]
try:
if position[0][0]['isOpen'] == False:
if probs >= confidence:
place_orders(client, prediction, risk, reward)
print("Entry:", position[0][0]['avgEntryPrice'])
print("Unrealised PnL %:", position[0][0]['unrealisedPnlPcnt'])
print("`^*^`" * 8, "\n")
time.sleep(5)
except (IndexError):
print("Position Error", "\n")
time.sleep(5)
def __init__(self, stg_run_id, **run_mode_params):
super().__init__(stg_run_id, **run_mode_params)
self.trader_api = bitmex(test=config.TEST_NET,
api_key=config.EXCHANGE_PUBLIC_KEY, api_secret=config.EXCHANGE_SECRET_KEY)
self.currency_balance_dic = {}
self.currency_balance_last_get_datetime = None
self.symbol_currency_dic = None
self.symbol_precision_dic = None
self._datetime_last_rtn_trade_dic = {}
self._datetime_last_update_position_dic = {}
def test_order(self):
client = bitmex.bitmex(test=True, api_key=self.api_key, api_secret=self.api_secret)
result = client.Order.Order_new(symbol="XBTUSD", ordType='Limit', orderQty=1, price=3691,
execInst='ParticipateDoNotInitiate', text='BB_LONG').result()
order = result[0]
order_id = order['orderID']
order_status = order['ordStatus'] # Canceled
print(f'order_id[{order_id}] status[{order_status}]')
print(result)
import bitmex
import smtrad
import time
import datetime as dt
import os
# Чтение файла с акками
login = input('Введите логин: ')
setdata = 'setdata.txt'
setdata = pd.read_csv(os.path.join(os.path.dirname(__file__),setdata), index_col = 'login')
api_key = setdata.loc[login, 'ak']
api_secret = setdata.loc[login, 'as']
# Подключение к BITMEX sm00th
client = bitmex.bitmex(test=True,
api_key = api_key,
api_secret = api_secret)
# Вводные данные
curr = setdata.loc[login, 'curr']
timeframe = setdata.loc[login, 'timeframe']
rsi_period=7
last_qt = client.Trade.Trade_getBucketed(symbol='XBTUSD', binSize='1h', count=1 , reverse=True).result()[0][0]['close']
balance = client.User.User_getWallet().result()[0]['amount'] * last_qt / 100000000
koeff = 4
orderQty = balance // koeff
poza = 0
time_dict = {'1m':60, '5m':300, '1h':3600}
print(login, timeframe, curr, orderQty)
