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 minutes_counter_after_trade(self, symbol, count_until): if len(Mt5.positions_get(symbol=symbol)) == 1: self.__recent_trade = True if len(Mt5.positions_get(symbol=symbol)) != 1 and self.__recent_trade: if not self.__allow_to_count: self.__allow_to_count = True self.__allowed_to_trade = False self.__recent_trade = False if datetime.now( ).second == 0 and self.__counter_flag and self.__allow_to_count: print( f"Your Expert Advisor will be allowed to trade in {count_until-self.__minutes_counter} minutes." ) self.__minutes_counter += 1 self.__counter_flag = False if datetime.now().second == 59: self.__counter_flag = True if self.__minutes_counter == count_until: print(f"Your Expert Advisor is allowed to trade.\n") self.__minutes_counter = 0 self.__counter_flag = True self.__allow_to_count = False self.__allowed_to_trade = True return self.__allowed_to_trade
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 send_transaction(ticker, volume, type): if not mt5.initialize(): print("initialize() failed, error code =", mt5.last_error()) quit() if type == 'sell': type = mt5.ORDER_TYPE_SELL elif type == 'buy': type = mt5.ORDER_TYPE_BUY request = { "action": mt5.TRADE_ACTION_DEAL, "symbol": ticker, "volume": volume, 'type': type, "type_time": mt5.ORDER_TIME_GTC } result = mt5.order_send(request) if result is not None: return result.comment else: return
def close_trade(request, result, deviation): symbol = request['symbol'] if request['type'] == mt5.ORDER_TYPE_BUY: trade_type = mt5.ORDER_TYPE_SELL price = mt5.symbol_info_tick(symbol).bid elif request['type'] == mt5.ORDER_TYPE_SELL: trade_type = mt5.ORDER_TYPE_BUY price = mt5.symbol_info_tick(symbol).ask position_id = result.order lot = request['volume'] close_request = { "action": mt5.TRADE_ACTION_DEAL, "symbol": symbol, "volume": lot, "type": trade_type, "position": position_id, "price": price, "deviation": deviation, "magic": 234000, "comment": "python request end", "type_time": mt5.ORDER_TIME_GTC, "type_filling": mt5.ORDER_FILLING_RETURN, } result = mt5.order_send(close_request)
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 get_data_mt5(symbol='EURUSD', bars=500, to=0, timeframe='H1'): if not mt5.initialize(): print("initialize() failed, error code =", mt5.last_error()) quit() concatenation = 'mt5.TIMEFRAME_' + timeframe evaluated = eval(concatenation) rates = mt5.copy_rates_from_pos(symbol, evaluated, 0, bars) mt5.shutdown() df = pd.DataFrame(rates) df.time = pd.to_datetime(df.time, unit='s') df = df.set_index('time') df['symbol'] = symbol df = df.rename( columns={ 'open': 'Open', 'high': 'High', 'low': 'Low', 'close': 'Close', 'tick_volume': 'Volume' }) df = df[[ 'symbol', 'Open', 'High', 'Low', 'Close', 'Volume', 'spread', 'real_volume' ]] return (df)
def per_change(symbol, delta): """Returns the percentage change in the price of asset in the given time-delta from the latest price in the terminal.""" mt5.symbol_select(symbol) # latest tick data. now_tick = mt5.symbol_info_tick(symbol) now_ask = now_tick.ask # latest ask price. now_time = now_tick.time # latest time of tick # setting past-time adjusting with delta. past_time = dt.datetime.fromtimestamp(now_time - delta) # Getting past tick past_tick = mt5.copy_ticks_from(symbol, past_time, 1, mt5.COPY_TICKS_INFO) past_ask = past_tick[0][2] # getting past ask. # calculating percentage change. per_chng = ((now_ask - past_ask) / past_ask) * 100 if symbol[3:6] == 'USD': return per_chng else: return -(per_chng)
def close_trade(action, buy_request, result, deviation): '''https://www.mql5.com/en/docs/integration/python_metatrader5/mt5ordersend_py ''' # create a close request symbol = buy_request['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 position_id = result.order lot = buy_request['volume'] close_request = { "action": mt5.TRADE_ACTION_DEAL, "symbol": symbol, "volume": lot, "type": mt5.ORDER_TYPE_SELL, "position": position_id, "price": price, "deviation": deviation, "magic": ea_magic_number, "comment": "python script close", "type_time": mt5.ORDER_TIME_GTC, # good till cancelled "type_filling": mt5.ORDER_FILLING_RETURN, } # send a close request result = mt5.order_send(close_request)
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 getBars(symbol, start, end=None, timeFrame=DAILY): # definimos o fuso horário como UTC #timezone = pytz.timezone("Etc/UTC") if symbol == None or type(symbol) != str: return None else: symbol = symbol.upper() if timeFrame == DAILY: timeFrame = mt5.TIMEFRAME_D1 elif timeFrame == INTRADAY: timeFrame = mt5.TIMEFRAME_M1 else: timeFrame = mt5.TIMEFRAME_D1 if end == None: end = datetime.now() if type(start).__name__ != 'datetime': if type(start).__name__ != 'int': print( 'Error, start should be a datetime from package datetime or int' ) else: start_day = datetime.now() #- timedelta(days=start) rates = mt5.copy_rates_from(symbol, timeFrame, start_day, start) # criamos a partir dos dados obtidos DataFrame rates_frame = pd.DataFrame(rates) if len(rates_frame) > 0: rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s') return rates_frame else: rates = mt5.copy_rates_range(symbol, timeFrame, start, end) # criamos a partir dos dados obtidos DataFrame rates_frame = pd.DataFrame(rates) rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s') return rates_frame
def convert_csv(timeframe=mt5.TIMEFRAME_D1, bars=1000): def load_data(symbol): try: ticker = pd.DataFrame( mt5.copy_rates_from_pos(symbol, mt5.TIMEFRAME_D1, 0, bars))['close'].rename(index=symbol) print(f'Symbol {symbol} Bars {BARS} ok') except RuntimeError: print(f'ERRO NO SYMBOL "{symbol}"') mt5.shutdown() quit() return ticker tickers_close = [load_data(symbol) for symbol in symbols] symbol_one = pd.DataFrame( mt5.copy_rates_from_pos(symbols[0], timeframe, 0, bars)) time_tickers = pd.to_datetime(symbol_one['time'], unit='s') mt5.shutdown() df = pd.DataFrame(tickers_close).T df['TIME'] = time_tickers df.set_index('TIME', inplace=True) df.to_csv( f'{str(datetime.now().replace(microsecond=0)).replace(":", "-")}.csv') print( f'From {str(time_tickers.iloc[0]).split(" ")[0]} to {str(time_tickers.iloc[-1]).split(" ")[0]}' )
def get_ticks(self, symbol, from_date, to_date): """ Gets OHLC price data for the specified symbol. :param symbol: The name of the symbol to get the price data for. :param from_date: Date from when to retrieve data :param to_date: Date where to receive data to :return: Tick data for symbol as dataframe """ ticks_dataframe = None # Get ticks from MT5 ticks = MetaTrader5.copy_ticks_range(symbol, from_date, to_date, MetaTrader5.COPY_TICKS_ALL) # If ticks is None, there was an error if ticks is None: error = MetaTrader5.last_error() self.__log.error(f"Error retrieving ticks for {symbol}: {error}") else: self.__log.debug(f"{len(ticks)} ticks retrieved for {symbol}.") # Create dataframe from data and convert time in seconds to datetime format try: ticks_dataframe = pd.DataFrame(ticks) ticks_dataframe['time'] = pd.to_datetime( ticks_dataframe['time'], unit='s') except RecursionError: self.__log.warning("Error converting ticks to dataframe.") return ticks_dataframe
def close_position(deal_id): open_positions = get_positions() open_positions = open_positions[open_positions['ticket'] == deal_id] order_type = open_positions['type'][0] symbol = open_positions['symbol'][0] volume = open_positions['volume'][0] if(order_type == mt5.ORDER_TYPE_BUY): order_type = mt5.ORDER_TYPE_SELL price = mt5.symbol_info_tick(symbol).bid else: order_type = mt5.ORDER_TYPE_BUY price = mt5.symbol_info_tick(symbol).ask close_request = { 'action': mt5.TRADE_ACTION_DEAL, 'symbol': symbol, 'volume': float(volume), 'type': order_type, 'position': deal_id, 'price': price, 'magic': 234000, 'comment': 'Close trade', 'type_time': mt5.ORDER_TIME_GTC, 'type_filling': mt5.ORDER_FILLING_IOC, } result = mt5.order_send(close_request) if result.retcode != mt5.TRADE_RETCODE_DONE: print('Failed to close order :(') else: print('Order successfully closed!')
def copy(self, symbol, date_from, date_to=None, count=None, timeframe=mt5.TIMEFRAME_H1): """ Args: symbol (list) : List of symbols Get all symbols : [i.name for i in mt5.symbols_get()] date_from (datetime): Date, the ticks are requested from date_to (datetime): Date, up to which the ticks are requested count (int) : The length of the data (minutes) timeframe (int) : Time timeframe of data sampling (mt5.TIMEFRAME) Form : mt5.TIMEFRAME_ + M(minute) / H(hour) / D(day) / W(week) / MN(month) + value """ self.data = [] self.date_from = date_from self.data_to = date_to self.count = count for i in range(len(symbol)): if count: data = mt5.copy_rates_from(symbol[i], timeframe, date_from, count).tolist() elif date_to: data = mt5.copy_rates_range(symbol[i], timeframe, date_from, date_to).tolist() else: print('Argument passed in error') return if data is None: print(f'{symbol[i]} data copy error, skip') else: self.data += [data] self.data = torch.FloatTensor(self.data).permute(1, 0, 2)
def connect(account=None, passw=None): #if not b3.connect(): #print(“Error on connection”, b3.last_error()) #exit(): if account == None and passw == None: res = mt5.initialize() else: res = mt5.initialize(login=account, password=passw) global ac, path, datapath, commonDatapath, company, platform, connected info = mt5.account_info() if info.margin_so_mode != mt5.ACCOUNT_MARGIN_MODE_RETAIL_NETTING: print( "It is NOT netting, but B3 should be netting trade mode!! Error!!" ) # B3 is Netting!! return False #elif info.margin_so_mode ==mt5.ACCOUNT_MARGIN_MODE_RETAIL_HEDGING: # print("It is hedding, not netting") #else: # print("It is something elese!!") #if info.margin_so_mode ==mt5.ACCOUNT_MARGIN_MODE_RETAIL_NETTING: # print("It is netting, not hedding") # B3 is Netting!! #elif info.margin_so_mode ==mt5.ACCOUNT_MARGIN_MODE_RETAIL_HEDGING: # print("It is hedding, not netting") #else: # print("It is something elese!!") if res: ac = mt5.terminal_info() path = ac.path datapath = ac.data_path commonDatapath = ac.commondata_path company = ac.company platform = ac.name connected = True return res
def Generator(curr="GBPUSD", period=14): Done = True rates = mt5.copy_rates_from_pos(curr, mt5.TIMEFRAME_M1, 0, 2) c = 0 open_list = [] high_list = [] low_list = [] close_list = [] while Done: lasttick = mt5.symbol_info_tick(curr) bid, ask = round(lasttick.bid, 5), round(lasttick.ask, 5) mid = round((bid + ask) / 2, 5) c += 1 check = rates[1][0] #rates = mt5.copy_rates_from_pos("GBPUSD", mt5.TIMEFRAME_M1, 0, 1) while check == rates[1][0]: rates = mt5.copy_rates_from_pos(curr, mt5.TIMEFRAME_M1, 0, 2) open, high, low, close, tickvol, spread = rates[0][1], rates[0][ 2], rates[0][3], rates[0][4], rates[0][5], rates[0][6] open_list.append(open) high_list.append(high) low_list.append(low) close_list.append(close) #if c>period: cci = CCI(high_list, low_list, close_list, period) if len(cci) == 0: cci = np.append(cci, 0) rsi = RSI(pd.Series(close_list), period) yield np.array( [bid, ask, mid, round(rsi.values[-1], 5), cci[-1] / 100])
def DataRequest(ticker, rates, plot): print("establish connection to MetaTrader 5 terminal...") if not mt5.initialize(): print("initialize() failed, error code =", mt5.last_error()) quit() # request rates from ticker tickerRates = mt5.copy_rates_from(ticker, mt5.TIMEFRAME_M1, datetime.now(), rates) #print those values print("Number of rates returned: " + str(len(tickerRates))) #create dataframe from rates and handle datetime as string for interpolation on pyplot tickerFrame = pd.DataFrame(tickerRates) tickerFrame['time'] = pd.to_datetime(tickerFrame['time'], unit='s') tickerFrame['time'] = tickerFrame['time'].astype(str) if (plot): plt.plot(tickerFrame['time'], tickerFrame['close'], 'b-', label='close') plt.show() return tickerFrame
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 close_position(deal_id): open_positions = positions_get() open_positions = open_positions[open_positions["ticket"] == deal_id] order_type = open_positions["type"][0] symbol = open_positions["symbol"][0] volume = open_positions["volume"][0] if (order_type == mt5.ORDER_TYPE_BUY): order_type = mt5.ORDER_TYPE_SELL price = mt5.symbol_info_tick(symbol).bid else: order_type = mt5.ORDER_TYPE_BUY price = mt5.symbol_info_tick(symbol).ask close_request = { "action": mt5.TRADE_ACTION_DEAL, "symbol": symbol, "volume": float(volume), "type": order_type, "position": deal_id, "price": price, "magic": 234000, "comment": "Close trade", "type_time": mt5.ORDER_TIME_GTC, "type_filling": mt5.ORDER_FILLING_IOC, } result = mt5.order_send(close_request) if result.retcode != mt5.TRADE_RETCODE_DONE: print("Failed to close order :(") else: print("Order successfully closed!")
def ATR_Calculator(y, m, d, symbol): mt5.initialize() # set time zone to UTC timezone = pytz.timezone("Etc/UTC") # create 'datetime' object in UTC time zone to avoid the implementation of a local time zone offset utc_from = datetime.datetime(y, m, d, tzinfo=timezone) # get 11 bars of any symbol that you want in 1D timeframe starting from given time in format of y=Year,m=Month,d=Day rates = mt5.copy_rates_from(symbol, mt5.TIMEFRAME_D1, utc_from, 32) # create DataFrame out of the obtained data rates_frame = pd.DataFrame(rates) DaysOn = len(rates_frame) # convert time in seconds into the datetime format rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s') # if you need to see the data print rates_frame. Otherwise let it be as a comment # print(rates_frame) # create the TR as an array with specified length if DaysOn < 3: return None else: TR = np.zeros(DaysOn - 2) # start to fill the TR for i in range(1, DaysOn - 1): TR[i - 1] = max(rates_frame['high'][i], rates_frame['close'][i - 1]) - min( rates_frame['low'][i], rates_frame['close'][i - 1]) # now make the ATR dictionary ATR = sum(TR[-10:-1]) / 10 ATR = {'time': rates_frame["time"].iloc[-1], 'ATR': ATR} return ATR
def getDailYBars( symbol, start, end=None): # sao inclusas barras com tempo de abertura <= end. # definimos o fuso horário como UTC #timezone = pytz.timezone("Etc/UTC") if end == None: end = datetime.now() if type(start).__name__ != 'datetime': if type(start).__name__ != 'int': print( 'Error, start should be a datetime from package datetime or int' ) else: start_day = datetime.now() #- timedelta(days=start) rates = mt5.copy_rates_from(symbol, mt5.TIMEFRAME_D1, start_day, start) # criamos a partir dos dados obtidos DataFrame rates_frame = pd.DataFrame(rates) rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s') return rates_frame else: rates = mt5.copy_rates_range(symbol, mt5.TIMEFRAME_D1, start, end) # criamos a partir dos dados obtidos DataFrame rates_frame = pd.DataFrame(rates) rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s') return rates_frame return x
def f_be_de_parte1(param_data): # Filtrado de operaciones ganadoras (operaciones ancla) param_data['capital_acm'] = param_data['profit_acm'] + 100000 ganadoras = param_data[param_data.Profit > 0] ganadoras = ganadoras.reset_index(drop=True) ganadoras["Ratio"] = (ganadoras["Profit"] / abs(ganadoras["profit_acm"])) df_anclas = ganadoras.loc[:, [ 'close_time', "open_time", 'Type', "Symbol", 'Profit', "profit_acm", "capital_acm", "Ratio", "Time", "Time.1", "Price", "Volume" ]] df_anclas = df_anclas.reset_index(drop=True) # Criterio de selección de operaciones abiertas por cada ancla ocurrencias = [] file_list = [] for x in df_anclas.index: df = param_data[ (param_data.open_time <= df_anclas["close_time"][x]) & (param_data.close_time > df_anclas["close_time"][x] )].loc[:, ['Type', 'Symbol', 'Volume', 'Profit', "Price", "pips"]] df['close_time_ancla'] = pd.Timestamp(df_anclas['close_time'][x]) file_list.append(df) ocurrencias.append(len(df)) all_df = pd.concat(file_list, ignore_index=True) # Descarga de precios para cada operación abierta float_price = [] if not mt5.initialize(): print("initialize() failed, error code =", mt5.last_error()) quit() for i in range(len(all_df)): utc_from = datetime(all_df['close_time_ancla'][i].year, all_df['close_time_ancla'][i].month, all_df['close_time_ancla'][i].day) utc_to = utc_from + timedelta(1) symbol = all_df['Symbol'][i] ticks = mt5.copy_ticks_range(symbol, utc_from, utc_to, mt5.COPY_TICKS_ALL) ticks_frame = pd.DataFrame(ticks) ticks_frame['time'] = pd.to_datetime(ticks_frame['time'], unit='s') tick_time = next(x for x in ticks_frame['time'] if x >= all_df['close_time_ancla'][i]) price = ticks_frame.loc[ticks_frame['time'] == tick_time] if all_df["Type"][i] == "buy": price = price["bid"].mean() else: price = price["ask"].mean() float_price.append(price) float_prices = pd.DataFrame(columns=['float_price'], data=float_price) all_df = all_df.join(float_prices) all_df = f_columnas_pips_v2(all_df) all_df["float_P&L"] = (all_df["Profit"] / all_df["pips"]) * all_df["float_pips"] all_df = all_df[all_df['float_P&L'] < 0].reset_index(drop=True) return all_df, df_anclas
def __enter__(self): """ Открываем подключение к терминалу """ # подключимся к MetaTrader 5 if not mt5.initialize(path=self.path, server=self.server, login=self.login, password=self.password): print("initialize() failed") mt5.shutdown()
def get_rates_range(self): rates = mt5.copy_rates_range(self.currency_pair_name, self.timeframe, self.datetime_from, self.datetime_to) if rates != None: return rates else: raise RuntimeError('copy_rates_range() failed. error code =', mt5.last_error())
def closeingPrice(name): info = mt5.symbol_info_tick(name) if info is None: insertion(name) time.sleep(0.5) info = mt5.symbol_info_tick(name) return info.ask return info.ask
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 getOrders(): # returns a dataframe with all active orders orders = mt5.orders_get() if orders == None or len(orders) == 0: print("No orders, error code={}".format(mt5.last_error())) return None else: print("Total orders:", len(orders)) df = pd.DataFrame(list(orders), columns=orders[0]._asdict().keys()) return df
def _fxAdjust(exposure, pair): """Converts the passed exposure in USD""" if pair[0:3] == 'USD': adjustedExpo = exposure / mt5.symbol_info_tick(pair).ask else: adjustedExpo = exposure * mt5.symbol_info_tick(pair).ask return adjustedExpo
def get_prices(self): symbol = Trader.symbol bid = mt5.symbol_info_tick(symbol).bid ask = mt5.symbol_info_tick(symbol).ask spread = round(abs(ask - bid) * 1000) threading.Timer(1.0, self.get_prices).start() self._view.askPriceDisplay.setText(f"{ask:.3f}") self._view.bidPriceDisplay.setText(f"{bid:.3f}") self._view.spreadDisplay.setText(f"{spread}")