def print_terminal_info():
# request connection status and parameters
print(mt5.terminal_info())
# request account info
print(mt5.account_info())
# get data on MetaTrader 5 version
print(mt5.version())
def __init__(self,symbol:str):
# conecte-se ao MetaTrader 5
if not mt5.initialize():
print("initialize() failed")
mt5.shutdown()
# consultamos o estado e os parâmetros de conexão
print(mt5.terminal_info())
# obtemos informações sobre a versão do MetaTrader 5
print(mt5.version())
self.symbol = symbol
def test0():
if not mt5.initialize():
print("initialize() failed")
mt5.shutdown()
print('Version:', mt5.version())
t1 = TimeUtility.xmTime(2020, 9, 18, 15, 12)
t0 = t1 - TimeUtility.deltaMinute(5)
values = mt5.copy_rates_range("US30Cash", mt5.TIMEFRAME_M1, t0, t1)
for value in values:
t = pd.to_datetime(value[0], unit='s')
naive_time = t.to_pydatetime()
print(t, naive_time, TimeUtility.toXm(naive_time), value)
mt5.shutdown()
pass
def __init__(self, buyingCurrency, sellingCurrency, timeFrame, lotSize, cycleTime):
logging.basicConfig(format='%(asctime)s,%(levelname)s,%(message)s', datefmt='%m/%d/%Y,%H:%M:%S')
self.timeFrame = timeFrame
self.logger = logging.getLogger('TraderLog')
self.logger.setLevel(logging.DEBUG)
self.advisorsList = list()
if not mt5.initialize():
logger.error("initialize() failed, error code =" + mt5.last_error()[2])
mt5.shutdown()
raise Exception(errorMsg)
# request connection status and parameters
print(mt5.terminal_info())
# get data on MetaTrader 5 version
print(mt5.version())
def test0():
if not mt5.initialize():
print("initialize() failed")
mt5.shutdown()
print('Version:', mt5.version())
t1 = nowXm()
t0 = t1 - deltaMinute(5)
values = mt5.copy_rates_range("US30Cash", mt5.TIMEFRAME_M1, t0, t1)
for value in values:
t = pd.to_datetime(value[0], unit='s')
pytime = t.to_pydatetime()
print(t, pytime, toXm(pytime), value)
mt5.shutdown()
pass
def __init__(self):
# Connect to MetaTrader5. Opens if not already open.
# Logger
self.__log = logging.getLogger(__name__)
# Open MT5 and log error if it could not open
if not MetaTrader5.initialize():
self.__log.error("initialize() failed")
MetaTrader5.shutdown()
# Print connection status
self.__log.debug(MetaTrader5.terminal_info())
# Print data on MetaTrader 5 version
self.__log.debug(MetaTrader5.version())
def test():
# connect to MetaTrader 5
if not mt5.initialize():
print("initialize() failed")
mt5.shutdown()
print('Version:', mt5.version())
#dji = mt5.copy_rates_range('US30Cash', mt5.TIMEFRAME_M30, Now() - DeltaDay(2), Now())
#print(dji)
# request 1000 ticks from EURAUD
euraud_ticks = mt5.copy_ticks_from("US30Cash", datetime(2020,4,17,23), 1000, mt5.COPY_TICKS_ALL)
# request ticks from AUDUSD within 2019.04.01 13:00 - 2019.04.02 13:00
audusd_ticks = mt5.copy_ticks_range("AUDUSD", datetime(2020,1,27,13), datetime(2020,1,28,13), mt5.COPY_TICKS_ALL)
# get bars from different symbols in a number of ways
eurusd_rates = mt5.copy_rates_from("EURUSD", mt5.TIMEFRAME_M1, datetime(2020,1,28,13), 1000)
eurgbp_rates = mt5.copy_rates_from_pos("EURGBP", mt5.TIMEFRAME_M1, 0, 1000)
eurcad_rates = mt5.copy_rates_range("EURCAD", mt5.TIMEFRAME_M1, datetime(2020,1,27,13), datetime(2020,1,28,13))
#print(eurusd_rates)
# shut down connection to MetaTrader 5
mt5.shutdown()
return
def inicializa_servidor_MT5(tipo_saida) -> bool:
file_relat = define_saida_print(tipo_saida)
isInitialized = False
try:
isInitialized = mt5.initialize() # initialize MetaTrader 5
except RuntimeError:
print(
"### ERRO ### Não consegiu logar no MT5, verifique credenciais...\n"
)
return False
if not isInitialized:
print('### ERRO ### Não conseguiu inicializar o MT5...\n',
file=file_relat)
else:
print('### OK ### MT5 inicializado com sucesso...\n',
file=file_relat)
# request connection status and parameters
print(mt5.terminal_info(), "\n", file=file_relat)
# get data on MetaTrader 5 version
listaMT5 = mt5.version()
print('Versão MT5 :',
listaMT5[1],
' Data:',
listaMT5[2],
'\n',
file=file_relat)
return isInitialized
register_matplotlib_converters()
import MetaTrader5 as mt5
account=40513145
authorized=mt5.login(account, password="******")
# connect to MetaTrader 5
if not mt5.initialize():
mt5.initialize()
# request connection status and parameters
print(mt5.terminal_info())
# get data on MetaTrader 5 version
print(mt5.version())
start_date=datetime(2021,1,27,10)
end_date=datetime(2021,1,27,11)
# request 1000 ticks from EURAUD
#datetime(year,month,day,hour)
euraud_ticks = mt5.copy_ticks_from("EURAUD", start_date, 1000, mt5.COPY_TICKS_ALL)
# request ticks from AUDUSD within 2019.04.01 13:00 - 2019.04.02 13:00
audusd_ticks = mt5.copy_ticks_range("AUDUSD", start_date, end_date, mt5.COPY_TICKS_ALL)
# get bars from different symbols in a number of ways
eurusd_rates = mt5.copy_rates_from("EURUSD", mt5.TIMEFRAME_M1,start_date, 1000)
eurgbp_rates = mt5.copy_rates_from_pos("EURGBP", mt5.TIMEFRAME_M1, 0, 1000)
eurcad_rates = mt5.copy_rates_range("EURCAD", mt5.TIMEFRAME_M1, start_date, end_date)
import MetaTrader5 as mt5
#____________Initializing Metatrader5____________#
mt5.initialize()
print(mt5.version(), '\n')
print(mt5.terminal_info(), '\n')
print(mt5.account_info(), '\n')
order = mt5.orders_get() #getting all pending orders
#____________Calculating required Margin_________________#
margin = mt5.order_calc_margin(
mt5.ORDER_TYPE_BUY, order[0].symbol, order[0].volume_initial,
order[0].price_open) #returns required margin in account currency
print('\nMargin requirement for buying {0} @ {1} is ${2}'.format(
order[0].symbol, order[0].price_open, margin))
#____________Calculating Profit/loss_____________#
volatility = float(input('Enter the desired volatility in percentage: '))
percentage = volatility * (order[0].price_open / 100)
profit = mt5.order_calc_profit(
mt5.ORDER_TYPE_BUY, order[0].symbol, order[0].volume_initial,
order[0].price_open,
(order[0].price_open +
percentage)) #returns potential P/L in account currency
print('\n Profit on {0} at {1} with {2}% volatility is ${3}'.format(
order[0].symbol, order[0].price_open, volatility, profit))
import MetaTrader5 as mt5
import pandas as pd
mt5.initialize() #Connecting the program to MT5
print(mt5.version(), '\n') #Version info of MT5 software
#___________Creating a terminal info dictionary____________#
trm_dict = mt5.terminal_info()._asdict() #status info of the MT5 terminal
for i in trm_dict:
print("{0}: {1}".format(i, trm_dict[i]))
#____________Creating an account info dictionary____________#
account_dict = mt5.account_info()._asdict() #various information of the loggedin account
for i in account_dict:
print(i, ':', account_dict[i])
#_______________puttng info in a pandas DataFrame_______________#
account_df = pd.DataFrame(list(account_dict.items()), columns=['property', 'value'])
trm_df = pd.DataFrame(list(trm_dict.items()), columns=['property', 'value'])
#_________________Brokerage account Login example_________________________#
'''SYNTAX: mt5.login(loginID, server='server_name', password='******')'''
loginID = 14000510
authentication = mt5.login(loginID, server='MetaQuotes-Demo', password='******')
if authentication:
print(mt5.account_info())
else:
print("failed to login to trade account {0}".format(loginID))
def version(self):
return "{}.{}".format(mt5.version()[0], mt5.version()[1])
import MetaTrader5 as mt5
def OnTick():
print("OnTick")
return
mt5.initialize()
v = mt5.version()
print(v)
d = mt5.symbol_info_tick("EURUSD").time_msc
while (True):
tick = mt5.symbol_info_tick("EURUSD")
print(tick)
if tick.time_msc != d:
d = tick.time_msc
OnTick()
def World(filename=None,
train_test = 'train',
episodes=10,
train_test_split = 0.75,
trading_fee = .0002,
time_fee = .001,
memory_size = 3000,
gamma = 0.99,
epsilon_min = 0.01,
batch_size = 64,
train_interval = 10,
learning_rate = 0.001,
render_show=False,
display=False,
save_results=False
):
start = time.time()
generator = TAStreamer(filename=filename, mode='train', split=train_test_split)
episode_length = round(int(len(pd.read_csv(filename))*train_test_split), -1)
environment = Indicator_1(data_generator=generator,
trading_fee=trading_fee,
time_fee=time_fee,
episode_length=episode_length)
action_size = len(Indicator_1._actions)
state = environment.reset()
state_size = len(state)
try:
symbol = re.findall(r'C:\\Users\\ndhun\\Autotrding\\([^.]+)',filename)[0]
except:
symbol = ""
agent = DDDQNAgent(state_size=state_size,
action_size=action_size,
memory_size=memory_size,
episodes=episodes,
episode_length=episode_length,
train_interval=train_interval,
gamma=gamma,
learning_rate=learning_rate,
batch_size=batch_size,
epsilon_min=epsilon_min,
train_test=train_test,
symbol=symbol)
# Warming up the agent
if (train_test == 'train'):
for _ in range(memory_size):
action = agent.act(state)
next_state, reward, done, _ = environment.step(action)
agent.observe(state, action, reward, next_state, done, warming_up=True)
if display:
print('completed mem allocation: ', time.time() - start)
# Training the agent
loss_list=[]
val_loss_list=[]
reward_list=[]
epsilon_list=[]
metrics_df=None
if train_test == "train":
best_loss = 9999
best_reward = 0
for ep in range(episodes):
ms = time.time()
state = environment.reset()
rew = 0
loss_list_temp = []
val_loss_list_temp = []
for _ in range(episode_length):
action = agent.act(state)
next_state, reward, done, _ = environment.step(action)
loss = agent.observe(state, action, reward, next_state,
done) # loss would be none if the episode length is not % by 10
state = next_state
rew += reward
if(loss):
loss_list_temp.append(round(loss.history["loss"][0],3))
val_loss_list_temp.append(round(loss.history["val_loss"][0],3))
if display:
print("Ep:" + str(ep)
+ "| rew:" + str(round(rew, 2))
+ "| eps:" + str(round(agent.epsilon, 2))
+ "| loss:" + str(round(loss.history["loss"][0], 4))
+ "| runtime:" + str(time.time() - ms))
print("Loss=", str(np.mean(loss_list_temp)), " Val_Loss=", str(np.mean(val_loss_list_temp)))
loss_list.append(np.mean(loss_list_temp))
val_loss_list.append(np.mean(val_loss_list_temp))
reward_list.append(rew)
epsilon_list.append(round(agent.epsilon, 2))
agent.save_model()
metrics_df=pd.DataFrame({'loss':loss_list,'val_loss':val_loss_list,'reward':reward_list,'epsilon':epsilon_list})
if save_results:
metrics_df.to_csv(r'C:\Users\ndhun\Autotrding\perf_metrics.csv')
if(train_test=='test'):
agent.load_model()
generator = TAStreamer(filename=filename, mode='test', split=train_test_split)
environment = Indicator_1(data_generator=generator,
trading_fee=trading_fee,
time_fee=time_fee,
episode_length=episode_length,)
if train_test=='trade':
agent.load_model()
generator = TAStreamer(filename=filename, mode='trade',period=4, split=train_test_split)
environment = Indicator_1(data_generator=generator,
trading_fee=trading_fee,
time_fee=time_fee,
episode_length=episode_length)
if not mt5.initialize():
print("initialize() failed, error code =",mt5.last_error())
quit()
print(mt5.version())
# connect to the trade account without specifying a password and a server
# attempt to enable the display of the GBPUSD in MarketWatch
selected=mt5.symbol_select("GBPUSD",True)
if not selected:
print("Failed to select GBPUSD")
mt5.shutdown()
quit()
# prepare the buy request structure
symbol = "GBPUSD"
symbol_info = mt5.symbol_info(symbol)
if symbol_info is None:
print(symbol, "not found, can not call order_check()")
mt5.shutdown()
quit()
account=50481525
authorized=mt5.login(account) # the terminal database password is applied if connection data is set to be remembered
if authorized:
print("connected to account #{}".format(account))
print(mt5.account_info())
else:
print("failed to connect at account #{}, error code: {}".format(account, mt5.last_error()))
# 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()
done = False
state = environment.reset()
q_values_list=[]
state_list=[]
action_list=[]
reward_list=[]
trade_list=[]
while not done:
action, q_values = agent.act(state, test=True)
state, reward, done, info = environment.step(action,True)
if 'status' in info and info['status'] == 'Closed plot':
done = True
else:
reward_list.append(reward)
calc_returns=environment.return_calc(render_show)
if calc_returns:
trade_list.append(calc_returns)
if(render_show):
environment.render()
if train_test=='trade':
print('Waiting..')
else:
#if bought --> tpsl
q_values_list.append(q_values)
state_list.append(state)
action_list.append(action)
print('Reward = %.2f' % sum(reward_list))
trades_df=pd.DataFrame(trade_list)
action_policy_df = pd.DataFrame({'q_values':q_values_list,'state':state_list,'action':action_list})
if save_results:
trades_df.to_csv(r'C:\Users\ndhun\Autotrding\trade_list.csv')
action_policy_df.to_pickle(r'C:\Users\ndhun\Autotrding\action_policy.pkl')
action_policy_df.to_csv(r'C:\Users\ndhun\Autotrding\action_policy_CSV.csv')
if display:
print("All done:", str(time.time() - start))
return({"metrics_df":metrics_df,
"trades_df":trades_df,
"action_policy_df":action_policy_df,
"reward_list":reward_list})
