def check(n, count_wins, count_losses):
if n > 0:
txt = "buy"
else:
txt = "sell"
while True:
spread = round(
mt5.symbol_info("USDJPY").ask - mt5.symbol_info("USDJPY").bid, 7)
print("\r",
txt,
", current profit: ",
mt5.account_info().profit,
", spread: ",
round(spread * 10, 4),
flush=True)
if mt5.account_info().profit > 0.03:
count_wins += 1
win(n, count_wins, count_losses)
break
elif mt5.account_info().profit < -0.21:
count_losses += 1
loss(n, count_wins, count_losses)
break
else:
pass
time.sleep(0.2)
return count_wins, count_losses
def swap(self):
"""Returns the swap that you will pay or receive in USD after taking that position."""
if self.symbol[-1:-5:-1] in ['ESYN', 'SAN.'
]: #Calculaing swap for Shares and ETFs
if self.position() == 'Long':
swap_rate = mt5.symbol_info(self.symbol).swap_long
elif self.position() == 'Short':
swap_rate = mt5.symbol_info(self.symbol).swap_short
swapPerDay = ((self.exposure() * swap_rate) / 100) / 365
return swapPerDay
else: #Calculating swap for forex, commodities, index.
if self.position() == 'Long':
swap_rate = mt5.symbol_info(self.symbol).swap_long
elif self.position() == 'Short':
swap_rate = mt5.symbol_info(self.symbol).swap_short
swapPerDay = swap_rate * self.volume
if self.symbol[0:3] == 'USD':
adjustedSwap = swapPerDay / mt5.symbol_info_tick(
self.symbol).ask
return adjustedSwap
elif self.symbol in list1:
return self._fxAdjust(swapPerDay, list1[self.symbol])
else:
return swapPerDay
def check(n, count_wins, count_losses, j, curr_pair):
if n > 0:
txt = "buy"
else:
txt = "sell"
while True:
spread = round(
mt5.symbol_info(curr_pair).ask - mt5.symbol_info(curr_pair).bid, 7)
print("\r",
txt,
", current profit: ",
mt5.account_info().profit,
", spread: ",
round(spread * 10, 4),
flush=True)
if mt5.account_info().profit > 0.02:
count_wins += 1
win(count_wins, count_losses, curr_pair)
break
elif mt5.account_info().profit <= -0.1:
count_losses += 1
loss(count_wins, count_losses, curr_pair)
break
else:
pass
k = (1 + j) * 30
print("checking price in: ", k, " seconds.")
time.sleep(k)
return count_wins, count_losses
def buyOrder(symbolId, volume, price=None, sl=None, tp=None): # Buying !!
#b=b3.buy(symbol_id,volume, price, sl, tp ))
#if b3.checkorder(b):
# if b3.send(b): #buying
# print('order sent to B3')
# else:
# print('Error : ',b3.getLastError())
#else:
# print('Error : ',b3.getLastError())
if not connected:
print(
"In order to use this function, you must be connected to B3. Use function connect()"
)
return
symbol_info = mt5.symbol_info(symbolId)
#print("symbol=",symbolId," info=",symbol_info)
if symbol_info is None:
setLastError(symbolId + " not found, can not create buy order")
return None
# se o símbolo não estiver disponível no MarketWatch, adicionamo-lo
if not symbol_info.visible:
#print(symbolId, "is not visible, trying to switch on")
if not mt5.symbol_select(symbolId, True):
setLastError("symbol_select({}}) failed! symbol=" + symbolId)
return None
point = mt5.symbol_info(symbolId).point
deviation = 20
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbolId,
"volume": float(volume),
"type": mt5.ORDER_TYPE_BUY,
"deviation": deviation,
"magic": random.randrange(100, 100000),
"comment": "order by mt5b3",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_RETURN,
}
if price == None: # order a mercado
request['action'] = mt5.TRADE_ACTION_DEAL
request['type'] = mt5.ORDER_TYPE_BUY
request['price'] = mt5.symbol_info_tick(symbolId).ask
else: # order limitada
request['action'] = mt5.TRADE_ACTION_PENDING
request['type'] = mt5.ORDER_TYPE_BUY_LIMIT
request['price'] = float(price)
if sl != None:
request["sl"] = sl
if tp != None:
request["tp"] = tp
return request
def __init__(
self,
expert_name,
version,
symbol,
magic_number,
lot: float,
stop_loss, # It calls a functions that tries to close the deal, it is the stop you want.
emergency_stop_loss, # It set stop on chart as a protection
# if something went wrong with the stop_loss.
take_profit, # The same of stop_loss but for profit.
emergency_take_profit, # The same of emergency_stop_loss but for gain
start_time='9:15', # It is the hour and minutes that the expert advisor are able to start to run.
finishing_time='17:30', # No new position can be opened after that time.
ending_time='17:50', # If there is a position opened it will be closed.
fee=0.0,
):
self.expert_name = expert_name
self.version = version
self.symbol = symbol
self.magic_number = magic_number
self.lot = lot
self.stop_loss = stop_loss
self.emergency_stop_loss = emergency_stop_loss
self.take_profit = take_profit
self.emergency_take_profit = emergency_take_profit
self.start_time_hour, self.start_time_minutes = start_time.split(':')
self.finishing_time_hour, self.finishing_time_minutes = finishing_time.split(
':')
self.ending_time_hour, self.ending_time_minutes = ending_time.split(
':')
self.fee = fee
self.loss_deals = 0
self.profit_deals = 0
self.total_deals = 0
self.balance = 0.0
self.ticket = 0
print('\nInitializing the basics.')
self.initialize()
self.select_symbol()
self.prepare_symbol()
self.sl_tp_steps = Mt5.symbol_info(
self.symbol).trade_tick_size / Mt5.symbol_info(self.symbol).point
print('Initialization successfully completed.')
print()
self.summary()
print('Running')
print()
def open_trade(action, symbol, lot, sl, tp, deviation):
if action == 'buy':
trade_type = mt5.ORDER_TYPE_BUY
price = mt5.symbol_info_tick(symbol).ask
elif action == 'sell':
trade_type = mt5.ORDER_TYPE_SELL
price = mt5.symbol_info_tick(symbol).bid
tp *= -1
sl *= -1
point = mt5.symbol_info(symbol).point
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": lot,
"type": trade_type,
"price": price,
"sl": price - sl * point,
"tp": price + tp * point,
"deviation": deviation,
"magic": 234000,
"comment": "python request",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_RETURN,
}
result = mt5.order_send(request)
return result, request
def open_buy():
global result_order_buy
# establish connection to the MetaTrader 5 terminal
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
# prepare the buy request structure
symbol_info = mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol, "not found, can not call order_check()")
mt5.shutdown()
quit()
# if the symbol is unavailable in MarketWatch, add it
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, exit",symbol)
mt5.shutdown()
quit()
price = mt5.symbol_info_tick(symbol).ask
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": lot,
"type": mt5.ORDER_TYPE_BUY,
"price": price,
"sl": price - sl_buy * point,
"tp": price + tp_buy * point,
"deviation": deviation,
"magic": 234000,
"comment": "python script open",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_FOK,
}
# send a trading request
result = mt5.order_send(request)
# check the execution result
print("1. order_send(): by {} {} lots at {} with deviation={} points".format(symbol,lot,price,deviation))
if result.retcode != mt5.TRADE_RETCODE_DONE:
print("2. order_send failed, retcode={}".format(result.retcode))
# request the result as a dictionary and display it element by element
result_dict=result._asdict()
for field in result_dict.keys():
print(" {}={}".format(field,result_dict[field]))
# if this is a trading request structure, display it element by element as well
if field=="request":
traderequest_dict=result_dict[field]._asdict()
for tradereq_filed in traderequest_dict:
print(" traderequest: {}={}".format(tradereq_filed,traderequest_dict[tradereq_filed]))
print("shutdown() and quit")
mt5.shutdown()
quit()
print("2. order_send done, ", result)
print(" buy opened position with POSITION_TICKET={}".format(result.order))
result_order_buy=result.order
return(result_order_buy)
def open_trade(action, symbol, lot, sl_points, tp_points, deviation):
'''https://www.mql5.com/en/docs/integration/python_metatrader5/mt5ordersend_py
'''
# prepare the buy request structure
symbol_info = get_info(symbol)
if action == 'buy':
trade_type = mt5.ORDER_TYPE_BUY
price = mt5.symbol_info_tick(symbol).ask
elif action == 'sell':
trade_type = mt5.ORDER_TYPE_SELL
price = mt5.symbol_info_tick(symbol).bid
point = mt5.symbol_info(symbol).point
buy_request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": lot,
"type": trade_type,
"price": price,
"sl": price - sl_points * point,
"tp": price + tp_points * point,
"deviation": deviation,
"magic": ea_magic_number,
"comment": "sent by python",
"type_time": mt5.ORDER_TIME_GTC, # good till cancelled
"type_filling": mt5.ORDER_FILLING_RETURN,
}
# send a trading request
result = mt5.order_send(buy_request)
return result, buy_request
def getSharesStep(assetId, money=None):
if not connected:
print(
"In order to use this function, you must be connected to B3. Use function connect()"
)
return
return mt5.symbol_info(assetId).volume_step
def vwap_reversion(symbol, period):
"""
Implements a simple mean reversion using the vwap
:symbol: the symbol of the instrument
:period: how often you want to check the last vwap against the current price (in seconds)
"""
print(f"reversion {symbol} started")
# buy and sell buffers to store the orders
buy_buf = []
sell_buf = []
while True:
symbol_inf = mt5.symbol_info(symbol)
mean = vwap(symbol)[0][-1]
print(
f"{symbol} mean: {mean}\nask: {symbol_inf.ask}\nask-mean: {symbol_inf.ask-mean}"
)
if symbol_inf.ask < 0.995 * mean:
buy_buf.append(
open_order(symbol, "buy", 10, symbol_inf.ask * 1.005))
print(f"{symbol} bought")
# elif symbol_inf.ask > 1.005 * mean:
# # sell_buf.append(open_order(symbol, "sell", 1))
# for i in buy_buf[::-1]:
# close_order(symbol, "sell", i.volume, i.order)
# sell_buf.append(buy_buf.pop())
# print(f"sold {symbol}: {i}")
for i, j in enumerate(buy_buf):
print(f"printing {symbol} buy buffer[{i}]:", j)
time.sleep(period)
def open_position(symbol,
order_type,
volume,
tp_distance=None,
stop_distance=None):
symbol_info = mt5.symbol_info(symbol)
sl, tp, order, price = None, None, None, None
if symbol_info is None:
print(f"{symbol} is not found")
return
if not symbol_info.visible:
print(f"{symbol} is not visible, trying to switch on")
if not mt5.symbol_select(symbol, True):
print(f"symbol_select for {symbol} is failed, exiting")
return
print(f"{symbol} found")
point = symbol_info.point
if order_type == "BUY":
order = mt5.ORDER_TYPE_BUY
price = mt5.symbol_info_tick(symbol).ask
if stop_distance:
sl = price - (stop_distance * point)
if tp_distance:
tp = price + (tp_distance * point)
if order_type == "SELL":
order = mt5.ORDER_TYPE_SELL
price = mt5.symbol_info_tick(symbol).bid
if stop_distance:
sl = price + (stop_distance * point)
if tp_distance:
tp = price - (tp_distance * point)
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": float(volume),
"type": order,
"price": price,
"sl": sl,
"tp": tp,
"magic": 234000,
"comment": "",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_IOC
}
result = None
try:
result = mt5.order_send(request)
except result is None or result.retcode != mt5.TRADE_RETCODE_DONE:
print("Unable to send order")
return
print(f"{symbol} Order sent")
return result.retcode
def f_pip_size(param_ins):
try:
mt5.initialize(login=41671538, server='MetaQuotes-Demo',password='******')
pip_size = int(0.1/mt5.symbol_info(param_ins)._asdict().get('trade_tick_size'))
return pip_size
except:
return print('Ticker no válido')
def historyData(Symbol):
mt5.initialize(server="ForexClub-MT5 Demo Server",
login=500063649,
password="******")
# print(mt5.terminal_info())
# print(mt5.version())
listSymbols = mt5.symbols_get()
# [x.name for x in listSymbols]
# Symbol=np.random.choice(FXmajor, 1)[0]
print(Symbol)
pointValue = mt5.symbol_info(Symbol).point
# mt5.Buy("EURUSD", 0.1,price=11395,ticket=9)
Num_velas = 1000
# Copying data to pandas data frame
# rates = mt5.copy_rates_from_pos(Symbol, mt5.TIMEFRAME_M1, 0, Num_velas)
rates = mt5.copy_rates_range(Symbol, mt5.TIMEFRAME_H1,
datetime(2021, 1, 10), datetime.now())
# rates = mt5.copy_rates_range("ES", mt5.TIMEFRAME_D1, datetime(2019, 1, 15), datetime(2019, 1, 25))
# rates = mt5.copy_rates_from_pos(Symbol, mt5.TIMEFRAME_M1, 0, Num_velas)
# Deinitializing MT5 connection
mt5.shutdown()
# create DataFrame out of the obtained data
rates_frame = pd.DataFrame(rates)
# convert time in seconds into the datetime format
rates_frame.index = pd.to_datetime(rates_frame['time'], unit='s')
rates_frame.columns = [
'time', 'Open', 'High', 'Low', 'Close', 'tick_volume', 'spread',
'real_volume'
]
return rates_frame
def synthesize(symbol1, symbol2, periods):
"""Takes 2 MT5 currency symbols with common USD and returns a DataFrame of OCHLV
of the price of first symbol denominated in second symbol.
note: Requires both the assets to have USD in common, ie. either denomination
or base."""
# Asset on which the pricing will be based.
base_asset = pd.DataFrame(
mt5.copy_rates_from_pos(symbol1, mt5.TIMEFRAME_H1, 1, period))
# Asset to quote the base in, generally a currency.
quote_asset = pd.DataFrame(
mt5.copy_rates_from_pos(symbol2, mt5.TIMEFRAME_H1, 1, period))
# converting timestamps to Datetime-index.
base_asset['time'] = pd.to_datetime(base_asset['time'], unit='s')
quote_asset['time'] = pd.to_datetime(quote_asset['time'], unit='s')
baseAsset_quote = mt5.symbol_info(symbol1).currency_profit
if symbol1[0:3] == 'USD': # Dollar based ie. USDJPY, USDCHF...
if symbol2[3:6] == 'USD':
basequote = (1 / base_asset[['open', 'high', 'low', 'close']]) * (
1 / quote_asset[['open', 'high', 'low', 'close']])
basequote.rename(columns={
'high': 'low',
'low': 'high'
},
inplace=True)
else:
# basequote = quote_asset[['open', 'high', 'low', 'close']] / base_asset[['open', 'high', 'low', 'close']]
basequote = (1 / base_asset[['open', 'high', 'low', 'close']]
) * quote_asset[['open', 'high', 'low', 'close']]
basequote.rename(columns={
'high': 'low',
'low': 'high'
},
inplace=True)
elif symbol1[
3:
6] == 'USD' or baseAsset_quote == 'USD': # Dollar quoted ie. EURUSD, SnP500...
if symbol2[3:6] == 'USD':
basequote = base_asset[[
'open', 'high', 'low', 'close'
]] / quote_asset[['open', 'high', 'low', 'close']]
# basequote.rename(columns={'high':'low', 'low':'high'}, inplace=True)
else:
basequote = base_asset[[
'open', 'high', 'low', 'close'
]] * quote_asset[['open', 'high', 'low', 'close']]
# averaging volume.
basequote['vol'] = (
(base_asset['tick_volume'] + quote_asset['tick_volume']) / 2)
basequote.set_index(keys=[base_asset['time']], inplace=True)
return basequote
def OnTick():
print("OnTick")
if mt5.positions_total() == 0:
n = rnd.random()
if n > 0.5:
print("Buy")
point = mt5.symbol_info(symbol).point
price = mt5.symbol_info_tick(symbol).ask
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": OnLot(),
"type": mt5.ORDER_TYPE_BUY,
"price": price,
"sl": price - SL * point,
"tp": price + TP * point,
"deviation": deviation,
"magic": magic,
"comment": "python script open",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_FOK,
}
result = mt5.order_send(request)
print("Error ", result.retcode)
else:
print("Sell")
point = mt5.symbol_info(symbol).point
price = mt5.symbol_info_tick(symbol).bid
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbol,
"volume": OnLot(),
"type": mt5.ORDER_TYPE_SELL,
"price": price,
"sl": price + SL * point,
"tp": price - TP * point,
"deviation": deviation,
"magic": magic,
"comment": "python script open",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_FOK,
}
result = mt5.order_send(request)
print("Error ", result.retcode)
return
def runner(self):
"""Returns an order request. Will automatically close 'pct_close' percent of all positions and set the stoploss
to the opening price + 'sl_points'
Will implement a ticket system to allow specification of a position"""
for pos in mt5.positions_get():
position_id = mt5.TradePosition(pos).ticket
symbol = mt5.TradePosition(pos).symbol
order = mt5.TradePosition(pos).type
point = mt5.symbol_info(symbol).point
price = mt5.TradePosition(pos).price_open
bid = mt5.symbol_info_tick(symbol).bid
ask = mt5.symbol_info_tick(symbol).ask
current_price = mt5.TradePosition(pos).price_current
pct_close = 80
sl_points = 30
tp_points = 500
if order == 0: # Buy
new_sl = round(price + sl_points * point, 3)
if current_price < new_sl:
print("Desired SL is under current price")
else:
self.close_custom_pct(pct_close, ticket=position_id)
request = {
"action": mt5.TRADE_ACTION_SLTP,
"symbol": symbol,
"position": position_id,
"sl": new_sl,
"tp": round(ask + tp_points * point, 3),
"magic": self.magic,
"comment": f"python runner {symbol}"
}
if order == 1: # Sell
new_sl = round(price - sl_points * point, 3)
if current_price > new_sl:
print("Desired SL is over current price")
else:
self.close_custom_pct(pct_close, ticket=position_id)
request = {
"action": mt5.TRADE_ACTION_SLTP,
"symbol": symbol,
"position": position_id,
"sl": new_sl,
"tp": round(bid - (tp_points * point), 3),
"magic": self.magic,
"comment": f"python runner {symbol}"
}
try:
result = mt5.order_send(request)
self.order_error_check(result)
except UnboundLocalError:
print(f"Desired SL : {new_sl}")
print(
f"Current Price : {mt5.TradePosition(pos).price_current}"
)
def sellOrder(symbolId, volume, price=None, sl=None, tp=None): # Selling !!
symbol_info = mt5.symbol_info(symbolId)
#print("symbol=",symbolId," info=",symbol_info)
if symbol_info is None:
setLastError(symbolId + " not found, can not create buy order")
return None
# se o símbolo não estiver disponível no MarketWatch, adicionamo-lo
if not symbol_info.visible:
#print(symbolId, "is not visible, trying to switch on")
if not mt5.symbol_select(symbolId, True):
setLastError("symbol_select({}}) failed! symbol=" + symbolId)
return None
point = mt5.symbol_info(symbolId).point
deviation = 20
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": symbolId,
"volume": float(volume),
"type": mt5.ORDER_TYPE_SELL,
"deviation": deviation,
"magic": random.randrange(100, 100000),
"comment": "order by mt5b3",
"type_time": mt5.ORDER_TIME_DAY,
"type_filling": mt5.ORDER_FILLING_FOK,
}
if price == None: # order a mercado
request['action'] = mt5.TRADE_ACTION_DEAL
request['type'] = mt5.ORDER_TYPE_SELL
request['price'] = mt5.symbol_info_tick(symbolId).ask
else: # order limitada
request['action'] = mt5.TRADE_ACTION_PENDING
request['type'] = mt5.ORDER_TYPE_SELL_LIMIT
request['price'] = float(price)
if sl != None:
request["sl"] = sl
if tp != None:
request["tp"] = tp
return request
def open_position(
pair, order_type,
size, tp_distance=None,
stop_distance=None,
):
"""Open a position."""
symbol_info = mt5.symbol_info(pair)
if symbol_info is None:
print(pair, 'not found')
return
if not symbol_info.visible:
print(pair, 'is not visible, trying to switch on')
if not mt5.symbol_select(pair, True):
print('symbol_select({}}) failed, exit', pair)
return
print(pair, 'found!')
point = symbol_info.point
# volume_step = symbol_info.volume_step
if(order_type == 'BUY'):
order = mt5.ORDER_TYPE_BUY
price = mt5.symbol_info_tick(pair).ask
if(stop_distance):
sl = price - (stop_distance * point)
if(tp_distance):
tp = price + (tp_distance * point)
if(order_type == 'SELL'):
order = mt5.ORDER_TYPE_SELL
price = mt5.symbol_info_tick(pair).bid
if(stop_distance):
sl = price + (stop_distance * point)
if(tp_distance):
tp = price - (tp_distance * point)
request = {
'action': mt5.TRADE_ACTION_DEAL,
'symbol': pair,
'volume': float(size),
'type': order,
'price': price,
'sl': sl,
'tp': tp,
'magic': 234000,
'comment': 'bot order',
'type_time': mt5.ORDER_TIME_GTC,
'type_filling': mt5.ORDER_FILLING_IOC,
}
result = mt5.order_send(request)
if result.retcode != mt5.TRADE_RETCODE_DONE:
print('Failed to send order :(')
else:
print('Order successfully placed!')
def get_symbol_info(self, symbol=None):
"""Get data on the specified financial instrument.
Args:
symbol (str, optional): Financial instrument name. Defaults to None.
Returns:
dict: Symbol information
"""
instrument = symbol if symbol else self.symbol
return mt5.symbol_info(instrument)._asdict()
def spread_is_ok(df, i, symbol):
info = mt5.symbol_info(symbol)
# Get the spread in pips rather than points
spread = info.spread * info.point
if spread <= df.loc[i, 'atr'] * 1 / 3:
return True
else:
return False
def get_spread_from_ticks(ticks_frame, symbol):
"""
:param ticks_frame: pd.DataFrame, all tick info
:return: pd.Series
"""
spread = pd.Series((ticks_frame['ask'] - ticks_frame['bid']) *
(10**mt5.symbol_info(symbol).digits),
index=ticks_frame.index,
name='ask_bid_spread_pt')
spread = spread.groupby(spread.index).mean() # groupby() note 56b
return spread
def getAfforShares(assetId, money=None, price=None):
if money == None:
money = mt5.account_info().margin_free
if price == None:
close = mt5.symbol_info_tick(assetId).last
else:
close = price
step = mt5.symbol_info(assetId).volume_step
free = 0
while free * close < money:
free = free + step
return free - step
def open_position(pair,
order_type,
size,
tp_distance=None,
stop_distance=None):
symbol_info = mt5.symbol_info(pair)
if symbol_info is None:
print(f"{pair} not found")
return
if not symbol_info.visible:
print(f"{pair} is not visible, trying to switch on")
if not mt5.symbol_select(pair, True):
print(f"symbol_select({pair}) failed, exit")
return
print(f"{pair} found!")
point = symbol_info.point
volume_step = symbol_info.volume_step
if (order_type == "BUY"):
order = mt5.ORDER_TYPE_BUY
price = mt5.symbol_info_tick(pair).ask
if (stop_distance):
sl = price - (stop_distance * point)
if (tp_distance):
tp = price + (tp_distance * point)
if (order_type == "SELL"):
order = mt5.ORDER_TYPE_SELL
price = mt5.symbol_info_tick(pair).bid
if (stop_distance):
sl = price + (stop_distance * point)
if (tp_distance):
tp = price - (tp_distance * point)
request = {
"action": mt5.TRADE_ACTION_DEAL,
"symbol": pair,
"volume": float(size),
"type": order,
"price": price,
"sl": sl,
"tp": tp,
"magic": 234000,
"comment": "",
"type_time": mt5.ORDER_TIME_GTC,
"type_filling": mt5.ORDER_FILLING_IOC,
}
result = mt5.order_send(request)
if result.retcode != mt5.TRADE_RETCODE_DONE:
print("Failed to send order :(")
else:
print("Order successfully placed!")
def checkAllSigs(numBefore,
timePeriod,
signals,
verbose=True,
sendMail=True,
placeorder=True):
maxTime = None
recVals = None
currTime = dt.now()
tradeSigs = []
for i, currSig in enumerate(signals):
rates = getData(numBefore, timePeriod, currSig, timeDict)
boll = getBollBands(rates.close)
rsi = getRSI(rates.close)
filteredDf, maxTime = cleanDf(rates, boll, rsi)
makeTrade, order_type = checkMakeTradeVariant(filteredDf)
# exit()
# recVals, maxTime = getMostRecent(rsi, boll, rates)
# makeTrade, order_type = checkMakeTrade(recVals)
spr = mt5.symbol_info(currSig).spread
if spr < 50:
if verbose:
print(
f'Signal {i}:\t{currSig}\t\tSpread:{spr}\tMake trade = {makeTrade}'
)
pass
else:
if verbose: print(f'Signal {i}:\t{currSig}\t\tSpread:{spr}\tSKIP')
continue
# if verbose: print(f'Signal {i}:\t{currSig}\t\tSpread:{spr}\t\tMake trade = {makeTrade}')
# If there's a signal which should be traded, open a window
if makeTrade:
tradeSigs.append(currSig)
if placeorder:
placeOrder(currSig, order_type, 100, 100)
if sendMail and len(tradeSigs) > 0:
sendEmail(
f'Subject: Trading bot making {len(tradeSigs)} trades at {currTime.strftime("%H:%M:%S")} on {tradeSigs}'
)
if verbose:
print(
f'\nTrading bot found {len(tradeSigs)} suggested trades at {currTime.strftime("%H:%M:%S")}\t Make trades on signals {tradeSigs}'
)
return maxTime
def to_him_who_has_more_shall_be_given():
''' Track the profit on the different pairs in a basket.
Every n bars reallocate n % of the trade volume from the least
profitable to the most profitable. '''
positions = mt5.positions_get()
if len(positions) == 0:
return
# How much to reallocate at a time
close_percent = 0.1
# How many bars to wait in between reallocation
reallocation_cycle = 3
baskets = get_best_and_worst_pairs_of_baskets(positions)
if not baskets:
return
# Get current server time (I think this is actually more like "last update time"
# of the passed symbol. so it won't change if the market is closed)
server_time = mt5.symbol_info('EURUSD')._asdict()['time']
for basket in baskets:
worst_position = baskets[basket]['worst']
best_position = baskets[basket]['best']
# print('\n',baskets[basket],'\n')
# print('\n',best_position,'\n')
# iono how i wanna quantify one trade being n% more profitable...
# how do i give meaning to the profitability of a trade...
# maybe i just say f it and go strictly time based
# so like.. after 3 bars start moving funds
# and move 5% every 3 bar or something. that 3% will become a smaller
# and smaller number each time but i can solve that later if i want
# See if 3 candles have closed since the last update to that trade
time_passed = server_time - best_position['time_update']
basket_timeframe = basket.split('_')[1]
if time_passed >= tf_to_sec[basket_timeframe] * reallocation_cycle:
# Reallocate the funds. So partial close on basket['worst'] and new entry on ['best']
# 'volume' in dict is the current trade volume. im just goinng to override that value
# with the amount i wanna close so I can pass that dict to close_trades() as is
reallocation_lot_size = round(worst_position['volume'] * close_percent, 2)
worst_position['volume'] = reallocation_lot_size
close_trades([worst_position])
symbol = best_position['symbol']
direction = best_position['direction']
enter_manual_trade(symbol, basket, basket_timeframe, reallocation_lot_size, direction, pair_data)
def enter_manual_trade(symbol, basket, timeframe, volume, direction, pair_data) -> None:
''' This is used by to_him_who_has_more_shall_be_given() and enters
a market order on a specific symbol'''
# If '.a' or some other suffix got added to the symbol
# remove that in order to access pair_data
x = symbol.split('.')[0]
digits = pair_data[x]['digits']
atr = pair_data[x]['atr'][timeframe]
if direction == 'buy':
price = mt5.symbol_info(symbol).ask
stop_loss = price - 1.5 * atr
take_profit = price + 5 * atr
type = mt5.ORDER_TYPE_BUY
else:
price = mt5.symbol_info(symbol).bid
stop_loss = price + 1.5 * atr
take_profit = price - 5 * atr
type = mt5.ORDER_TYPE_SELL
request = {
'action': mt5.TRADE_ACTION_DEAL,
'symbol': symbol,
'volume': float(volume), # int will error
'sl': round(stop_loss, digits),
'tp': round(take_profit, digits),
'deviation': 10,
'type': type,
'type_time': mt5.ORDER_TIME_GTC,
'type_filling': mt5.ORDER_FILLING_IOC,
'comment': f'{basket} reallocation',
}
# send a trading request
result = mt5.order_send(request)
if result.retcode != mt5.TRADE_RETCODE_DONE:
bot.send_message(chat_id=446051969, text=f'Manunal entry failed: {symbol} {timeframe} {direction}')
print(f'manual entry failed on {symbol} rc: {result.retcode}')
def Check(self, lot, symbol):
symbol_info = mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol, "not found.")
mt5.shutdown()
quit()
# if the symbol is unavailable in MarketWatch, add it
if not symbol_info.visible:
print(symbol, "is not visible, trying to switch on")
if not mt5.symbol_select(symbol,True):
print("symbol_select({}}) failed, exit",symbol)
mt5.shutdown()
quit()
def run(ticker):
#print(ticker)
if not mt5.initialize():
print("initialize() failed, error code =", mt5.last_error())
quit()
info = mt5.symbol_info(ticker)
if ticker not in USA_STOCKS:
df_1min = get_candles(
ticker, 'mt5.TIMEFRAME_M1',
5000).loc[:, ['open', 'high', 'low', 'close', 'volume']]
else:
# Получаем с яху, потому что с МТ5 с 15 минутным лагом
df_1min = get_american_candles(
ticker, '3d', '1m').loc[:,
['open', 'high', 'low', 'close', 'volume']]
df_5min = df_1min.resample('5Min').agg(AGG_DICT)
df_hour = df_1min.resample('60Min').agg(AGG_DICT)
df_day = df_1min.resample('1D').agg(AGG_DICT)
rsi = RSI()
df_1min = rsi.get_value_df(df_1min)
df_5min = rsi.get_value_df(df_5min)
signal = check_trade_conditions(ticker, df_day, df_hour, df_5min, df_1min)
if signal is not None:
signal_is_sent = check_signal_is_sent(ticker)
position = get_positions(ticker)
if (not signal_is_sent) and (position is None):
acceptable_PERC_loss = (open_close_5min_dif_mean[ticker] +
open_close_5min_dif_std[ticker])
last_close = df_5min.close[-1]
trade_size = calculate_trade_size(ticker, acceptable_PERC_loss,
last_close)
contract_size = info.trade_contract_size
min_volume = info.volume_min
trade_size = round(trade_size / contract_size / min_volume)
trade_size = trade_size * min_volume
direction = 'sell' if signal == 'sell' else 'buy'
send_message(ticker + ' ' + direction + ' ' + str(trade_size))
print(send_transaction(ticker, trade_size, direction))
cur_time = datetime.now().time()
print(cur_time, ticker, direction, trade_size)
set_signal_is_sent_flag(ticker)
def checkAllSigs(numBefore,
timePeriod,
signals,
verbose=True,
sendMail=True,
placeorder=True):
maxTime = None
recVals = None
currTime = dt.now()
tradeSigs = []
for i, currSig in enumerate(signals):
rates = getData(numBefore, timePeriod, currSig, timeDict)
rsi = getRSI(rates.close)
filteredDf, maxTime = cleanDf(rates, rsi)
makeTrade, order_type, rsi = checkMakeTrade(
filteredDf[filteredDf.Date == max(filteredDf.Date)])
spr = mt5.symbol_info(currSig).spread
if spr < 50:
if verbose:
print(f'Signal {i}:\t{currSig}\t\tSpread:{spr}' +
'\tRSI = %.2f' % rsi + f'\tMake trade = {makeTrade}')
pass
else:
if verbose: print(f'Signal {i}:\t{currSig}\t\tSpread:{spr}\tSKIP')
continue
# If there's a signal which should be traded, open a window
if makeTrade:
tradeSigs.append(currSig)
if placeorder:
placeOrder(currSig,
order_type,
pipsprof=50,
pipsloss=50,
lot=0.05)
if sendMail and len(tradeSigs) > 0:
sendEmail(
f'Subject: Trading bot making {len(tradeSigs)} trades at {currTime.strftime("%H:%M:%S")} on {tradeSigs}'
)
if verbose:
print(
f'\nTrading bot found {len(tradeSigs)} suggested trades at {currTime.strftime("%H:%M:%S")}\t Make trades on signals {tradeSigs}'
)
return maxTime
def stop_and_gain(self, comment=''):
if len(Mt5.positions_get()) == 1:
points = (Mt5.positions_get()[0].profit *
Mt5.symbol_info(self.symbol).trade_tick_size /
Mt5.symbol_info(self.symbol).trade_tick_value) / \
Mt5.positions_get()[0].volume
if points / Mt5.symbol_info(self.symbol).point >= self.take_profit:
self.profit_deals += 1
self.close_position(comment)
print(
f'Take profit reached. ('
f'{int(Mt5.history_deals_get((datetime.today() - timedelta(days=1)), datetime.now())[-1].profit)}'
f')\n')
if Mt5.history_deals_get((datetime.today() - timedelta(days=1)), datetime.now())[-1].symbol == \
self.symbol:
self.balance += int(
Mt5.history_deals_get(
(datetime.today() - timedelta(days=1)),
datetime.now())[-1].profit)
self.statistics()
elif ((points / Mt5.symbol_info(self.symbol).point) *
-1) >= self.stop_loss:
self.loss_deals += 1
self.close_position(comment)
print(
f'Stop loss reached. ('
f'{int(Mt5.history_deals_get((datetime.today() - timedelta(days=1)), datetime.now())[-1].profit)}'
f')\n')
if Mt5.history_deals_get((datetime.today() - timedelta(days=1)), datetime.now())[-1].symbol == \
self.symbol:
self.balance += int(
Mt5.history_deals_get(
(datetime.today() - timedelta(days=1)),
datetime.now())[-1].profit)
self.statistics()
