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)
