class BinanceAPI:
def __init__(self, api_key, api_secret):
API_KEY = api_key
API_SECRET = api_secret
self.client = Client(API_KEY, API_SECRET)
def get_ticker(self, pair):
try:
value = self.client.get_ticker(symbol=pair)
return value
except Exception as e:
print("Exception : " + str(e))
def get_current_price(self, pair):
try:
ticker = self.client.get_symbol_ticker(symbol=pair)
value = ticker["price"]
return float(value)
except Exception as e:
print("Exception : " + str(e))
def get_klines(self, pair, number):
try:
klines = pd.DataFrame(self.client.get_klines(symbol=pair, interval=Client.KLINE_INTERVAL_30MINUTE, limit=number),columns = ["OpenTime","Open","High","Low","Close","Volume","CloseTime","QuoteVolume","TradeCount","TakerVolume","TakerQuoteVolume","Ignore"])
value = klines[["OpenTime","Close","High","Low","Volume","QuoteVolume","TakerVolume","TakerQuoteVolume","TradeCount"]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(lambda x: datetime.fromtimestamp(int(x/1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_historical_klines(self, pair, start, end):
try:
klines = pd.DataFrame(self.client.get_historical_klines(start_str = start,end_str = end,symbol=pair, interval=Client.KLINE_INTERVAL_30MINUTE, limit=500),columns = ["OpenTime","Open","High","Low","Close","Volume","CloseTime","QuoteVolume","TradeCount","TakerVolume","TakerQuoteVolume","Ignore"])
value = klines[["OpenTime","Close","High","Low","Volume","QuoteVolume","TakerVolume","TakerQuoteVolume","TradeCount"]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(lambda x: datetime.fromtimestamp(int(x/1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return value
except Exception as e:
print('Exception : {}'.format(e))
def get_free_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return float(value["free"])
except Exception as e:
print('Exception : {}'.format(e))
def get_futures_balance(self, symbol):
try:
value = self.client.futures_account_balance()
balance = [balance["balance"] for balance in value if balance["asset"] == symbol]
return float(str(*balance))
except Exception as e:
print('Exception : {}'.format(e))
def create_limit_order(self, symbol, price, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_limit(
symbol=symbol,
side=side,
timeInForce=self.client.TIME_IN_FORCE_IOC,
price=price,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",symbol,price,quantity)
except Exception as e:
print("Exception : " + str(e))
def create_market_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_market(
symbol=symbol,
side=side,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",symbol,price,quantity)
except Exception as e:
print("Exception : " + str(e))
def create_test_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.create_test_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(symbol,quantity))
except Exception as e:
print("Exception : " + str(e))
def create_futures_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.futures_create_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
#print(order)
print("buy order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(symbol,quantity))
except Exception as e:
print("Exception : " + str(e))
def get_base_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["baseAsset"];
except Exception as e:
print("Exception : " + str(e))
def get_quote_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["quoteAsset"];
except Exception as e:
print("Exception : " + str(e))
def get_all_tickers(self):
try:
return self.client.get_all_tickers();
except Exception as e:
print("Exception : " + str(e))
def get_all_orders(self):
try:
return self.client.get_all_orders();
except Exception as e:
print("Exception : " + str(e))
if price['error']: # stop and restart socket bsm.stop() sleep(2) bsm.start() price['error'] = False else: df = price['BTCUSDT'] start_time = df.date.iloc[-1] - pd.Timedelta(minutes=5) df = df.loc[df.date >= start_time] max_price = df.price.max() min_price = df.price.min() if df.price.iloc[-1] < max_price * 0.95: try: order = client.futures_create_order(symbol='ETHUSDT', side='SELL', type='MARKET', quantity=100) break except Exception as e: print(e) elif df.price.iloc[-1] > min_price * 1.05: try: order = client.futures_create_order(symbol='ETHUSDT', side='BUY', type='MARKET', quantity=100) break except Exception as e: print(e) sleep(0.1) # properly stop and terminate WebSocket
class BinanceWrapperAPI(WrapperAPI):
# (n) means that parameter is necessary
def __init__(self, pair, target, precision):
self.pair = pair
self.precision = precision
self.target = target
self.client = Client(keys.binance_api_key, keys.binance_api_secret)
def get_my_balance_coin(self, coin):
balances = self.client.futures_account_balance()
balance = find(lambda v: v['asset'] == coin, balances)
return float(balance['withdrawAvailable']) if balance else 0
def get_mycoin(self):
return self.get_my_balance_coin('USDT')
def get_position_targ(self) -> Tuple[float, bool]:
risks = self.client.futures_position_information(symbol=self.target)
position = find(lambda v: v['symbol'] == self.pair, risks)
amt = float(position['positionAmt'])
return abs(amt), amt >= 0
def get_balance_interest(self):
amount, _ = self.get_position_targ()
return amount
def buy_order(self, amount: float):
return self.post_order_market("BUY", amount)
def sell_order(self, amount: float):
return self.post_order_market("SELL", amount)
def post_order_market(self, side: str, quantity: float):
try:
res = self.client.futures_create_order(
symbol=self.pair,
side=side,
type="MARKET",
# positionSide=pside,
quantity=roundt(quantity, self.precision))
return [True, res['orderId']]
except BinanceAPIException as e:
raise (e)
return [False, e]
def get_open_orders(self):
return self.client.get_open_orders(symbol=self.pair)
def get_position(self) -> Literal["none", "long", "shor"]:
amount, posi = self.get_position_targ()
if amount == 0:
return 'none'
return "long" if posi else "shor"
def get_ask(self):
return float(self.client.get_ticker(symbol=self.pair)['askPrice'])
def get_bid(self):
return float(self.client.get_ticker(symbol=self.pair)['bidPrice'])
def get_order_status(self, id) -> Literal["COMP", "NEW", "EXPIRE"]:
try:
res = self.client.futures_get_order(symbol=self.pair, orderId=id)
if res['status'] == "FILLED":
return "COMP"
# other: CANCELED, PARTIALLY_FILLED
return "NEW"
except BinanceAPIException as e:
return "EXPIRE"
class MomentumStrategy:
def __init__(self):
self.client = Client(api_key=API_KEY, api_secret=API_SECRET)
self.bsm_s = BinanceSocketManager(self.client)
self.bsm_f = BinanceSocketManager(self.client)
self.symbol = 'BTCUSDT'
self.bet_size = 0.001
self.interval = '15m'
self.data_limit = 200
self.lim1 = 0.3
self.lim2 = 0.8
self.last_signal = 0
self.column_names = [
'open_time', 'open', 'high', 'low', 'close', 'volume',
'close_time', 'quote_asset_volume', 'number_of_trades',
'taker_buy_base_asset_volume', 'taker_buy_quote_asset_volume',
'ignore'
]
self.position_open = False
self.buy_position = False
self.sell_position = False
self.client.futures_change_leverage(symbol=self.symbol, leverage=10)
self.conn_key_s = self.bsm_s.start_kline_socket(
self.symbol, self.web_socket_handler, interval=self.interval)
self.bsm_s.start()
time.sleep(2)
def web_socket_handler(self, data):
self.is_kline_closed = data['k']['x']
if self.is_kline_closed:
self.calculate_signal()
while self.last_signal == self.signal:
self.calculate_signal()
self.last_signal = self.signal
print(self.signal)
if not self.position_open:
#open order because kline is closed - runs just the first time
if self.signal >= self.lim1 and self.signal <= self.lim2:
self.position_open = True
self.buy_position = True
self.buy_bet_size = self.bet_size
self.client.futures_create_order(side='BUY',
quantity=self.bet_size,
symbol=self.symbol,
type='MARKET')
elif self.signal <= -self.lim1 and self.signal >= -self.lim2:
self.position_open = True
self.sell_position = True
self.sell_bet_size = self.bet_size
self.client.futures_create_order(side='SELL',
quantity=self.bet_size,
symbol=self.symbol,
type='MARKET')
#close positions if were open because kline is closed
else:
if self.buy_position:
self.position_open = False
self.buy_position = False
self.client.futures_create_order(
side='SELL',
quantity=self.buy_bet_size,
symbol=self.symbol,
type='MARKET')
if self.sell_position:
self.position_open = False
self.sell_position = False
self.client.futures_create_order(
side='BUY',
quantity=self.sell_bet_size,
symbol=self.symbol,
type='MARKET')
#open order because kline is closed
if self.signal >= self.lim1 and self.signal <= self.lim2:
self.position_open = True
self.buy_position = True
self.buy_bet_size = self.bet_size
self.client.futures_create_order(side='BUY',
quantity=self.bet_size,
symbol=self.symbol,
type='MARKET')
elif self.signal <= -self.lim1 and self.signal >= -self.lim2:
self.position_open = True
self.sell_position = True
self.sell_bet_size = self.bet_size
self.client.futures_create_order(side='SELL',
quantity=self.bet_size,
symbol=self.symbol,
type='MARKET')
def futures_socket(self, data):
pass
# self.ask = float(data['data']['a'])
# self.bid = float(data['data']['b'])
# self.price = (self.ask + self.bid)/2
def calculate_signal(self):
df = self.client.futures_klines(symbol=self.symbol,
interval=self.interval,
limit=self.data_limit)
df = pd.DataFrame(df, columns=self.column_names)
df['close'] = pd.to_numeric(df['close'])
nks = [4, 8, 16]
nkl = [16, 24, 32]
r1 = 12
r2 = 168
l = 198
for i in range(3):
df[f'ema_s_{i}'] = EMA(df['close'], window=nks[i]).ema_indicator()
df[f'ema_l_{i}'] = EMA(df['close'], window=nkl[i]).ema_indicator()
df[f'x{i}'] = df[f'ema_s_{i}'] - df[f'ema_l_{i}']
df[f'y{i}'] = df[f'x{i}'] / np.std(df['close'][l - r1:l])
df[f'z{i}'] = df[f'y{i}'] / np.std(df[f'y{i}'][l - r2:l])
df[f'u{i}'] = (df[f'z{i}'] * np.exp(-(df[f'z{i}']**2) / 4)) / (
np.sqrt(2) * np.exp(-1 / 2))
df['signal'] = (df['u0'] + df['u1'] + df['u2']) / 3
self.signal = df['signal'][l]
def strategy(self):
pass
class Orders:
def __init__(self,
SYMBOL,
LEWAR,
PYRAMID_MAX,
ORDER_SIZE,
is_it_for_real=False):
self.SYMBOL = SYMBOL
self.LEWAR = LEWAR
self.PYRAMID_MAX = PYRAMID_MAX
self.ORDER_SIZE = ORDER_SIZE
self.side = {"LONG": 'BUY', "SHORT": 'SELL'}
self.side_reversed = {
"SHORT": 'BUY',
"LONG": 'SELL',
"BUY": 'SELL',
"SELL": 'BUY'
}
if is_it_for_real:
with open("api_keys.txt") as d:
api_keys = d.readlines()
api_keys[0] = api_keys[0].strip()
self.client = Client(api_keys[0], api_keys[1])
self.zagranie_list = []
try:
client.futures_change_margin_type(symbol=self.SYMBOL + 'USDT',
marginType="ISOLATED")
except:
pass
self.client.futures_change_leverage(symbol=self.SYMBOL + 'USDT',
leverage=self.LEWAR)
def update(self):
l = len(self.zagranie_list)
for i, zagranie in enumerate(self.zagranie_list[::-1]):
zagranie.update()
if zagranie.state == 'closed':
zagranie.close()
del zagranie_list[l - 1 - i]
def order_size(self, price, balance):
#return 0.6**pyramid*ORDER_SIZE*balance*LEWAR/price
return self.ORDER_SIZE * balance * self.LEWAR / price
def get_balance(self):
a = self.client.futures_account_balance()
for e in a:
if e['asset'] == 'USDT':
return float(e['withdrawAvailable'])
def positionInfo(self):
a = self.client.futures_position_information()
for e in a:
if e['symbol'] == self.SYMBOL + 'USDT':
return e
def create_order(self, side, price=None, TARGET_CHANGE=True):
print(f"Opening {side}")
if len(self.zagranie_list) >= self.PYRAMID_MAX:
print("Pyramid max reached")
return None
balance = self.get_balance()
if price:
order = self.client.futures_create_order(
symbol=self.SYMBOL + 'USDT',
side=self.side[side],
type='LIMIT',
timeInForce=TIME_IN_FORCE_GTC,
quantity=self.order_size(price, balance),
price=price,
newOrderRespType="RESULT")
else:
order = self.client.futures_create_order(
symbol=SYMBOL + 'USDT',
side=self.side[side],
type='MARKET',
quantity=self.order_size(
self.price, balance), #JAKIS DOMYSLMY PRICE TRZRBA DAC
newOrderRespType="RESULT")
if TARGET_CHANGE:
if side == "LONG":
oco_limit_price = self.price * (1 + TARGET_CHANGE)
oco_stop_price = self.price * (1 - TARGET_CHANGE)
elif side == "SHORT":
oco_limit_price = self.price * (1 - TARGET_CHANGE)
oco_stop_price = self.price * (1 + TARGET_CHANGE)
zagranie = Zagranie(self, side, order['orderId'], oco_limit_price,
oco_stop_price)
self.zagranie_list.append(zagranie)
return order['orderId']
def close(self, side):
print(f"Closing {side}")
l = len(self.zagranie_list)
for i, zagranie in enumerate(self.zagranie_list[::-1]):
if zagranie.side == side:
zagranie.close()
del zagranie_list[l - 1 - i]
newPosition = -1 * LEVERAGE * allocationUSDT / priceDict[symbol]
newPosition = newPosition - (newPosition %
minTradeSizes[symbol])
tradeDict[symbol] = newPosition - positionDict[symbol]
else:
tradeDict[symbol] = -1 * positionDict[symbol]
for symbol in symbols:
if tradeDict[symbol] == 0:
continue
elif tradeDict[symbol] > 0:
quantity = tradeDict[symbol]
client.futures_create_order(
symbol=f"{symbol}USDT",
side=client.SIDE_BUY,
type=client.ORDER_TYPE_LIMIT,
timeInForce=client.TIME_IN_FORCE_GTC,
price=str(priceDict[symbol]),
quantity=f"{quantity:.3}")
sleep(0.1) # Comply with API rate limit
elif tradeDict[symbol] < 0:
quantity = -1 * tradeDict[symbol]
client.futures_create_order(
symbol=f"{symbol}USDT",
side=client.SIDE_SELL,
type=client.ORDER_TYPE_LIMIT,
timeInForce=client.TIME_IN_FORCE_GTC,
price=str(priceDict[symbol]),
quantity=f"{quantity:.3}")
sleep(0.1) # Comply with API rate limit
def main():
arg = docopt(__doc__, version=version)
api_key = getenv('BINANCE_FUTURES_API')
sec_key = getenv('BINANCE_FUTURES_SEC')
if not api_key and not sec_key:
print('please set these environment variables:\n'\
' BINANCE_FUTURES_API\n'\
' BINANCE_FUTURES_SEC', file=stderr)
return 1
if not api_key:
print('environment variable not found: BINANCE_FUTURES_API',
file=stderr)
return 1
if not sec_key:
print('environment variable not found: BINANCE_FUTURES_SEC',
file=stderr)
return 1
client = Client(api_key, sec_key)
sides = {
'buy': Client.SIDE_BUY,
'long': Client.SIDE_BUY,
'sell': Client.SIDE_SELL,
'short': Client.SIDE_SELL,
}
types = {
'limit': Client.ORDER_TYPE_LIMIT,
'market': Client.ORDER_TYPE_MARKET
}
tifs = {
'gtc': Client.TIME_IN_FORCE_GTC,
'ioc': Client.TIME_IN_FORCE_IOC,
'fok': Client.TIME_IN_FORCE_FOK
}
if arg['--verbose']:
print(arg, file=stderr)
else:
sys.tracebacklimit = 0
if arg['--help']:
print(__doc__, file=stderr)
return 0
elif arg['status']:
return client.get_system_status()['status']
elif arg['balance']:
if arg['futures']:
print(dumps(client.futures_account_balance()))
elif arg['spot']:
print(dumps(client.get_account()['balances']))
elif arg['coin']:
print(dumps(client.futures_coin_account_balance()))
return 0
elif arg['show']:
if arg['spot']:
if arg['orders']:
# if arg['--all']:
# print(dumps(client.get_all_orders()))
# else:
print(dumps(client.get_open_orders()))
elif arg['order']:
symbol = arg['<symbol>'].upper()
if arg['futures'] and not symbol.endswith('USDT'):
symbol += 'USDT'
if arg['cancel']:
if arg['futures']:
print(
client.futures_cancel_order(symbol=symbol,
orderid=arg['<orderid>'],
timestamp=timemilli()))
elif arg['spot']:
print('not implemented', file=stderr)
else: # create order
tif = tifs[arg['--tif']]
if arg['<side>'].strip().lower() in sides:
side = sides[arg['<side>'].strip().lower()]
else: # side is wrong
print('error: side should be either "buy|long" or "sell|short"'\
' not', arg['side'], file=stderr)
quantity = float(arg['<quantity>'])
if arg['--limit']:
if arg['--limit']:
price = float(arg['--limit'])
type_ = types['limit']
if arg['--test']:
print(
client.create_test_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
type=type_))
else: # actually send the order
if arg['futures']:
print(
client.futures_create_order(
symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
reduceOnly=arg['--reduce-only'],
timestamp=timemilli(),
type=type_))
elif arg['spot']:
print(
client.create_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
timeInForce=tif,
type=type_))
else: # limit given but price not
print('please provide --limit \033[33m<price>\033[0m.')
elif arg['--market']:
type_ = types['market']
if arg['--test']:
print(
client.create_test_order(symbol=symbol,
side=side,
quantity=quantity,
type=type_))
else: # actually send the order
if arg['futures']:
print(
client.futures_create_order(
symbol=symbol,
side=side,
quantity=quantity,
timestamp=timemilli(),
reduceOnly=arg['--reduce-only'],
type=type_))
elif arg['spot']:
print(
client.create_order(symbol=symbol,
side=side,
quantity=quantity,
price=price,
type=type_))
else: # limit or market not given
print('please provide either '\
'\033[33m --limit <price>\033[0m '\
'or \033[33m--market\033[0m', file=stderr)
else: # no arguments given
print(__doc__, file=stderr)
return 1
aapl['Close'], aapl['wr_14'], aapl['macd'], aapl['macd_signal'])
print("la señal vale:", wr_macd_signal)
# POSITION
close_price = aapl['Close']
if client.futures_position_information(
symbol=symbolo)[-1]['positionAmt'] != "0":
if client.futures_position_information(
symbol=symbolo
)[-1]['positionAmt'] != "0" and wr_macd_signal[
-1] == -1 and wr_macd_signal[-2] == 0 and COMPRANDO[0] == 1:
close_price = client.futures_create_order(symbol=symbolo,
side='SELL',
type="MARKET",
quantity=cantidad,
redueOnly='True')
telegram_send.send(
messages=["ORDEN DE CERRADA COMPRA WILL+MAC", symbolo])
print("ORDEN DE CERRADA COMPRA WILL+MAC", symbolo)
#if len(client.futures_get_open_orders(symbol=symbolo))!=0:
#client.futures_cancel_all_open_orders(symbol=symbolo)
elif client.futures_position_information(
symbol=symbolo)[-1]['positionAmt'] != "0" and wr_macd_signal[
-1] == 1 and wr_macd_signal[-2] == 0 and VENDIENDO[0] == 1:
close_price = client.futures_create_order(symbol=symbolo,
side='BUY',
type="MARKET",
quantity=cantidad,
redueOnly='True')
dfMarket.loc[dfMarket.index[-1], 'Argent Fixe']= client.futures_account()['maxWithdrawAmount']
dfMarket.loc[dfMarket.index[-1], 'Solde Net'] = client.futures_account()['totalWalletBalance']
try :
dfMarket.loc[dfMarket.index[-1], '%PnL'] = (float(client.futures_position_information()[0]['markPrice'])/float(client.futures_position_information()[0]['entryPrice']) -1)* float(client.futures_position_information()[0]['leverage'])*100
except :
dfMarket.loc[dfMarket.index[-1], '%PnL'] = 0.0
#check if the last row of SMA_50 is not empty
if not (pd.isnull(dfMarket.loc[dfMarket.index[-1], 'SMA_50'])):
#STRATEGY
dfMarket.loc[dfMarket.index[-1], 'signals'] = np.where((dfMarket.loc[dfMarket.index[-1], 'SMA_3'] > dfMarket.loc[dfMarket.index[-1], 'SMA_10'] and dfMarket.loc[dfMarket.index[-1], 'SMA_3'] > dfMarket.loc[dfMarket.index[-1], 'SMA_50']),1,0)
dfMarket.loc[dfMarket.index[-1], 'positions'] = dfMarket.loc[dfMarket.index[-1], 'signals'] - dfMarket.loc[dfMarket.index[-2], 'signals']
print(float(dfMarket.loc[dfMarket.index[-1], 'current_position']) )
print(dfMarket.loc[dfMarket.index[-1], 'positions'])
if dfMarket.loc[dfMarket.index[-1], 'positions'] == 1 and float(dfMarket.loc[dfMarket.index[-1], 'current_position']) == 0.0:
client.futures_create_order(symbol = symbol, side = 'BUY', type = "MARKET", quantity = float(amount))
print('BUY')
elif dfMarket.loc[dfMarket.index[-1], 'positions'] == -1 and float(dfMarket.loc[dfMarket.index[-1], 'positions'])!=0.0:
client.futures_create_order(symbol = symbol, side = 'SELL', type = "MARKET", quantity = float(client.futures_position_information()[0]['positionAmt']))
print('SELL')
else :
print('HOLD')
dfMarket.to_csv('tradind_result_30042020.csv', index=False))
#%% RESULT
dfMarket = pd.read_csv('tradind_result_30042020.csv', index_col = None)
try :
dfMarket = dfMarket.drop('Unnamed: 0', 1)
except:
pass
#if dfMarket.loc[dfMarket.index[-1], 'positions']
long = True
if MA_short - MA_short_prev < price / short_enter_s and MA_long - MA_long_prev < short_enter_l:
short = True
if MA_short - MA_short_prev < price / long_exit_s and MA_long - MA_long_prev < long_exit_l:
if abs(price / lastbuy + winloss_bias) > winloss_margin:
close_long = True
if MA_short - MA_short_prev > price / short_exit_s and MA_long - MA_long_prev > -short_exit_l:
if abs(lastsell / price + winloss_bias) > winloss_margin:
close_short = True
if long and holding == 0:
holding = 1
lastbuy = price
maxbuy = math.floor(holdingUSDT * leverage / price * 1000) / 1000
holdingBTC = maxbuy
client.futures_create_order(symbol="BTCUSDT",
side="BUY",
type="MARKET",
quantity=maxbuy)
notify.send("Long " + str(maxbuy) + " BTC at " + str(price))
print("Long " + str(maxbuy) + " BTC at " + str(price))
if short and holding == 0:
holding = -1
lastsell = price
maxsell = math.floor(holdingUSDT * leverage / price * 1000) / 1000
holdingBTC = maxsell
client.futures_create_order(symbol="BTCUSDT",
side="SELL",
type="MARKET",
quantity=maxsell)
notify.send("Short " + str(maxsell) + " BTC at " + str(price))
print("Short " + str(maxsell) + " BTC at " + str(price))
if close_long and holding == 1:
from candle_monitor import buy_signal, sell_signal
from functions import *
from api_data import api, secret
from binance.client import Client
from datetime import datetime as dt
import time
client = Client(api, secret)
tiker = 'ONEUSDT'
quantity = 5
try:
long_close_order = client.futures_create_order(
symbol=tiker,
side='SELL',
positionSide='BOTH',
type='MARKET',
quantity=quantity,
reduceOnly='true',
recvWindow=5000,
)
print('done')
except:
pass
class Buy_sell:
def __init__(self):
# Enter your own API-key here
binance_api_key = ''
# Enter your own API-secret here
binance_api_secret = ''
self.binance_client = Client(api_key=binance_api_key,
api_secret=binance_api_secret)
def order_limit_buy(self, symbol, q, p):
try:
# ast.literal_eval(
result = self.binance_client.order_limit_buy(symbol=symbol,
quantity=q,
price=p)
return result
except:
print("order buy error")
return None
def order_mkt_buy(self, symbol, q):
try:
result = self.binance_client.order_market_buy(symbol=symbol,
quantity=q)
return result
except:
print("order buy error")
return None
def order_limit_sell(self, symbol, q, p):
try:
result = self.binance_client.order_limit_sell(symbol=symbol,
quantity=q,
price=p)
return result
except:
print("order buy error")
return None
def order_mkt_sell(self, symbol, q):
try:
result = self.binance_client.order_market_sell(symbol=symbol,
quantity=q)
return result
except:
print("order buy error")
return None
def get_future_account(self):
return self.binance_client.futures_account()
# positionSide LONG or SHORT
# side BUY or SELL
def trailing_stop_mkt_future(self,
pair,
price=None,
q=None,
side=None,
positionSide="BOTH",
callbackRate=1,
leverage=20):
try:
self.change_leverage_future(pair, leverage)
except:
print('No need to change leverage type.')
try:
self.change_margin_type_future(pair, "ISOLATED")
except:
print("not need to change margin type")
if price:
his = self.binance_client.futures_create_order(
symbol=pair,
side=side,
type="TRAILING_STOP_MARKET",
quantity=q,
activationPrice=price,
callbackRate=callbackRate,
positionSide=positionSide)
else:
his = self.binance_client.futures_create_order(
symbol=pair,
side=side,
type="TRAILING_STOP_MARKET",
quantity=q,
callbackRate=callbackRate,
positionSide=positionSide)
return his
# LONG OR SHORT
def mkt_buy_sell_future(self,
pair,
quantity,
positionSide="LONG",
side='BUY',
leverage=0):
his = self.binance_client.futures_create_order(
symbol=pair,
side=side,
type="MARKET",
quantity=str(quantity),
positionSide=positionSide)
return his
def limit_buy_sell_future(self,
pair,
price,
quantity,
positionSide="LONG",
side='BUY',
leverage=0):
try:
self.change_leverage_future(pair, leverage)
except:
print('No need to change leverage type.')
try:
self.change_margin_type_future(pair, "ISOLATED")
except:
print("not need to change margin type")
his = self.binance_client.futures_create_order(
symbol=pair,
side=side,
price=str(price),
type="LIMIT",
quantity=str(quantity),
positionSide=positionSide)
return his
def change_leverage_future(self, pair, leverage):
self.change_margin_type_future(pair, "ISOLATED")
his = self.binance_client.futures_change_leverage(symbol=pair,
leverage=leverage)
return his
def change_margin_type_future(self, pair, marginType="ISOLATED"):
return self.binance_client.futures_change_margin_type(
symbol=pair, marginType=marginType)
class BinanceAPI:
def __init__(self, api_key, api_secret):
API_KEY = api_key
API_SECRET = api_secret
self.client = Client(API_KEY, API_SECRET)
def get_ticker(self, pair):
try:
value = self.client.get_ticker(symbol=pair)
return value
except Exception as e:
print("Exception : " + str(e))
def get_current_price(self, pair):
try:
ticker = self.client.get_symbol_ticker(symbol=pair)
value = ticker["price"]
return float(value)
except Exception as e:
print("Exception : " + str(e))
def get_klines(self, pair, number):
try:
klines = pd.DataFrame(
self.client.get_klines(symbol=pair,
interval=Client.KLINE_INTERVAL_30MINUTE,
limit=number),
columns=[
"OpenTime", "Open", "High", "Low", "Close", "Volume",
"CloseTime", "QuoteVolume", "TradeCount", "TakerVolume",
"TakerQuoteVolume", "Ignore"
])
value = klines[[
"OpenTime", "Close", "High", "Low", "Volume", "QuoteVolume",
"TakerVolume", "TakerQuoteVolume", "TradeCount"
]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(
lambda x: datetime.fromtimestamp(int(x / 1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_historical_klines(self, pair, start, end):
try:
klines = pd.DataFrame(self.client.get_historical_klines(
start_str=start,
end_str=end,
symbol=pair,
interval=Client.KLINE_INTERVAL_30MINUTE,
limit=500),
columns=[
"OpenTime", "Open", "High", "Low",
"Close", "Volume", "CloseTime",
"QuoteVolume", "TradeCount",
"TakerVolume", "TakerQuoteVolume",
"Ignore"
])
value = klines[[
"OpenTime", "Close", "High", "Low", "Volume", "QuoteVolume",
"TakerVolume", "TakerQuoteVolume", "TradeCount"
]].copy()
value.loc[:, "OpenTime"] = pd.to_datetime(value["OpenTime"].apply(
lambda x: datetime.fromtimestamp(int(x / 1000))))
value = value.set_index("OpenTime")
return value
except Exception as e:
print("Exception : " + str(e))
def get_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return value
except Exception as e:
print('Exception : {}'.format(e))
def get_free_balance(self, symbol):
try:
value = self.client.get_asset_balance(asset=symbol)
return float(value["free"])
except Exception as e:
print('Exception : {}'.format(e))
def get_futures_balance(self, symbol):
try:
value = self.client.futures_account_balance()
balance = [
balance["balance"] for balance in value
if balance["asset"] == symbol
]
return float(str(*balance))
except Exception as e:
print('Exception : {}'.format(e))
def create_limit_order(self, symbol, price, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_limit(
symbol=symbol,
side=side,
timeInForce=self.client.TIME_IN_FORCE_IOC,
price=price,
quantity=quantity)
print(order)
print(
"buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",
symbol, price, quantity)
except Exception as e:
print("Exception : " + str(e))
def create_market_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.order_market(symbol=symbol,
side=side,
quantity=quantity)
print(order)
print(
"buy order created.\nSymbol:{0:5}\nPrice:{1:5}\nQuantity:{2:5}",
symbol, price, quantity)
except Exception as e:
print("Exception : " + str(e))
def create_test_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.create_test_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
print(order)
print("buy order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(
symbol, quantity))
except Exception as e:
print("Exception : " + str(e))
def create_futures_order(self, symbol, quantity, side_str):
try:
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.futures_create_order(
symbol=symbol,
side=side,
type=self.client.ORDER_TYPE_MARKET,
quantity=quantity)
#print(order)
print("order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(
symbol, quantity))
except Exception as e:
print("Exception : " + str(e))
def create_futures_stoploss_order(self, symbol, quantity, side_str, price):
if side_str == "BUY":
side = self.client.SIDE_BUY
elif side_str == "SELL":
side = self.client.SIDE_SELL
order = self.client.futures_create_order(symbol=symbol,
stopPrice=price,
side=side,
type="STOP_MARKET",
quantity=quantity)
#print(order)
#print("order created.\nSymbol:{0:5}\nQuantity:{1:5}".format(symbol,quantity))
def cancel_futures_orders(self, symbol):
for i in range(0, 50):
try:
self.client.futures_cancel_all_open_orders(symbol=symbol)
except Exception as e:
print("Exception : " + str(e))
continue
break
def get_open_futures_orders(self, symbol):
try:
result = self.client.futures_get_open_orders(symbol=symbol)
return result
except Exception as e:
print("Exception : " + str(e))
def get_base_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["baseAsset"]
except Exception as e:
print("Exception : " + str(e))
def get_quote_asset(self, symbol):
try:
return self.client.get_symbol_info(symbol)["quoteAsset"]
except Exception as e:
print("Exception : " + str(e))
def get_all_tickers(self):
try:
return self.client.get_all_tickers()
except Exception as e:
print("Exception : " + str(e))
def get_all_orders(self):
try:
return self.client.get_all_orders()
except Exception as e:
print("Exception : " + str(e))
def get_trades_data(self, symbol, start, end):
try:
data = []
value = self.client.get_aggregate_trades(symbol=symbol,
startTime=start,
endTime=end)
value_max = [-float('inf'), -float('inf')]
value_min = [float('inf'), float('inf')]
#price = self.client.get_historical_klines(start_str = start, end_str = start + 60000, symbol=symbol, interval=Client.KLINE_INTERVAL_1MINUTE, limit=1)[0][1]
for i in value:
if len(data) == const.IMG_LENGTH:
break
data.append(
[float(i["p"]),
float(i["q"]), 0.3 if i["m"] else 0.6])
if len(data) < const.IMG_LENGTH:
data += [[0.0, 0.0, 0.0]] * (const.IMG_LENGTH - len(data))
data = data[:const.IMG_LENGTH]
data = pd.DataFrame(data)
data = (data - data.min()) / (data.max() - data.min())
data = (data - data.mean()) / data.std()
data = (data - data.min()) / (data.max() - data.min())
return data.values.tolist()
except Exception as e:
print("Exception : " + str(e))
data = []
data += [[0.0, 0.0, 0.0]] * (const.IMG_LENGTH)
return data