else: # Short position positionDict[symbol] = -1 * positionAmt else: # No position positionDict[symbol] = 0 return balanceUSDT, positionDict balanceUSDT, positionDict = get_position() # Check if all pairs were loaded, and set leverage. for symbol in symbols: assert symbol in positionDict.keys() client.futures_change_leverage(symbol=f"{symbol}USDT", leverage=LEVERAGE + 1) currentTime = datetime.today() if currentTime.hour >= 12: tradeTime = currentTime + timedelta(days=1) tradeTime = tradeTime.replace(hour=12, minute=0, second=0, microsecond=0) else: tradeTime = currentTime.replace(hour=12, minute=0, second=0, microsecond=0) tradeTime = datetime.now() while True: if datetime.now() < tradeTime: sleep(60) else: # TO DO
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]
LeverageAmount = os.getenv('LEVERAGE') BotName = os.getenv('BOTNAME') Debug = os.getenv('DEBUG') SwapTrades = os.getenv('SWAP_TRADES') #Debug = True # Dashboard url = '188.166.75.218' redis_port = 6379 redis_pass = '******' r = redis.Redis(host=url, port=redis_port, db=0, password=redis_pass) # Create Client and vars client = Client(api_key, api_secret) client.futures_change_leverage(symbol = 'BTCUSDT', leverage = LeverageAmount) CurrentSignal = "" TradeID = None # in order gen TradeSize = None # in BTC TradeBTCPrice = None # in USDT TradeStartTime = None # in GMT TradeProfit = 0 # in % TradeCall = None # long/short TradeStatus = False # active/inactive prevTradeCall = None prevType = None def MakeTrade(TradeType): global TradeStatus
import matplotlib.pyplot as plt from datetime import timedelta api_key ="aiNA7HfxZhhxEV4LIeHEv7rOTOs5RhuVhzmKVB3jo2JOdvdFQPs0Thn8wgURfBuV" api_secret = "PL9kr8PGEvkiqDtZkQrGKWffS4eNb3mEkGlYyv5d0hfPtg3qYJkmVkhvIe2rr19h" client = Client(api_key, api_secret) duration = timedelta(hours=8) leverage = 75 money_per_trade = 5 symbol = 'BTCUSDT' #min qty : 0.01 client.futures_change_leverage(symbol = symbol, leverage = leverage) precision = client.get_symbol_info(symbol)['baseAssetPrecision'] precision = 3 #amount = money_per_trade/float(client.futures_mark_price(symbol = symbol)['markPrice'])*leverage #amount = "{:0.0{}f}".format(amount, precision) amount = 0.01 current_tradeFlag = True column_names = ['Time','Mean','SMA_3','SMA_10','SMA_50','signals','positions','current_position','Argent Fixe','Solde Net','%PnL','infos'] dfMarket = pd.DataFrame(columns = column_names) launching_time = datetime.now() #on s'assure de terminer le programme en ayant fini les transactions while datetime.now() < (launching_time + duration) or float(dfMarket.loc[dfMarket.index[-1], 'current_position']) != 0.0: apiMarkPrice = client.futures_mark_price(symbol = symbol) time = datetime.fromtimestamp(apiMarkPrice['time']/1000).strftime("%Y-%m-%d %H:%M:%S")
short_MA_duration = tuning.short_MA_duration long_MA_duration = tuning.long_MA_duration long_enter_s = tuning.long_enter_s long_exit_s = tuning.long_exit_s short_enter_s = tuning.short_enter_s short_exit_s = tuning.short_exit_s long_enter_l = tuning.long_enter_l long_exit_l = tuning.long_exit_l short_enter_l = tuning.short_enter_l short_exit_l = tuning.short_exit_l winloss_margin = tuning.winloss_margin winloss_bias = tuning.winloss_bias leverage = tuning.leverage client.futures_change_leverage(symbol="BTCUSDT", leverage=leverage) startTime = datetime.today() if startTime.minute > 59: next_time = startTime + timedelta(hours=1) next_time = next_time.replace(minute=15, second=0, microsecond=0) elif startTime.minute > 44: next_time = startTime + timedelta(hours=1) next_time = next_time.replace(minute=0, second=0, microsecond=0) elif startTime.minute > 29: next_time = startTime next_time = next_time.replace(minute=45, second=0, microsecond=0) elif startTime.minute > 14: next_time = startTime next_time = next_time.replace(minute=30, second=0, microsecond=0) else:
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)