def get_candle_hl(self, tick):
timezone = pytz.timezone("Etc/UTC")
today = time.gmtime() # hours + 3
yesterday = datetime.utcnow() - timedelta(1)
utc_from = datetime(yesterday.year,
yesterday.month,
yesterday.day,
yesterday.hour,
yesterday.minute,
tzinfo=timezone)
utc_to = datetime(year=today[0],
month=today[1],
day=today[2],
hour=today[3] + 3,
minute=today[4],
tzinfo=timezone)
if tick == "1min":
timeframe = mt5.TIMEFRAME_M1
elif tick == "5min":
timeframe = mt5.TIMEFRAME_M5
elif tick == "15min":
timeframe = mt5.TIMEFRAME_M15
elif tick == "30min":
timeframe = mt5.TIMEFRAME_M30
elif tick == "1hr":
timeframe = mt5.TIMEFRAME_H1
elif tick == "4hr":
timeframe = mt5.TIMEFRAME_H4
rates = mt5.copy_rates_range("GBPJPY", timeframe, utc_from,
utc_to) # OHLC
high = rates[-2][2]
low = rates[-2][3]
return high, low
def main():
Mt5.initialize()
Mt5.login(settings.METATRADE.LOGIN,
password=settings.METATRADE.PASSWORD,
server=settings.METATRADE.SERVER)
for currency in models.Currency.objects.all().iterator(
): # type: models.Currency
print(currency)
name = f"{currency.first}{currency.second}".upper()
latest = models.Bar.objects.filter(
currency=currency).latest("time_marker__time_marker")
latest_datetime = datetime.combine(latest.time_marker.time_marker,
datetime.min.time())
date_to = datetime.utcnow() - timedelta(days=1)
items = Mt5.copy_rates_range(name, Mt5.TIMEFRAME_D1, latest_datetime,
date_to)
if items is None:
continue
for item in items:
close = item["close"]
high = item["high"]
low = item["low"]
t = datetime.utcfromtimestamp(item["time"]).date()
if t.weekday() in {6, 5}:
continue
time_marker = TimeMarker.objects.get_or_create(time_marker=t)[0]
print(currency, time_marker)
Bar.objects.update_or_create(currency=currency,
time_marker=time_marker,
defaults={
"close": close,
"high": high,
"low": low
})
def load_stocks_1h(stock_name, load_from_datetime, ema_periods=(20, 50, 200)):
'''
Loads hourly stock data.
:param stock_name: The symbol code, e.g. AUDUSD
:param load_from_datetime: This should be a datetime value e.g. dt.datetime.strptime("07/02/2020 15:00:00", "%d/%m/%Y %H:%M:%S")
:param ema_periods: A tuple indicating the periods for which EMA should be calculated.
:return: Returns a dictionary indexed by time. Each index is then a further dictionary see {dictionary}.keys() for more details
'''
mt5.initialize()
stock_data = mt5.copy_rates_range(stock_name, mt5.TIMEFRAME_H1,
load_from_datetime, dt.datetime.now())
dataset = {}
for datapoint in stock_data:
dataset[dt.datetime.utcfromtimestamp(datapoint[0])] = {
"OPEN": datapoint[1],
"HIGH": datapoint[2],
"LOW": datapoint[3],
"CLOSE": datapoint[4],
"VOLUME": datapoint[5],
"SPREAD": datapoint[6]
}
mt5.shutdown()
for period in ema_periods:
dataset = exponential_moving_average(dataset, period)
return dataset
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 get_rates_from_date(initials, start_date, end_date, show_last=False):
mt5.initialize()
values = mt5.copy_rates_range(
initials,
mt5.TIMEFRAME_M1,
start_date,
end_date
)
mt5.shutdown()
return values if show_last else values[:-1]
def get_bars(self, symbol, tf, utc_from, utc_to):
tf_to_mt = {
"M1": mt5.TIMEFRAME_M1,
"M5": mt5.TIMEFRAME_M5,
"M15": mt5.TIMEFRAME_M15,
"M30": mt5.TIMEFRAME_M30,
"H1": mt5.TIMEFRAME_H1,
"H4": mt5.TIMEFRAME_H4,
"D1": mt5.TIMEFRAME_D1,
"W1": mt5.TIMEFRAME_W1,
"MN": mt5.TIMEFRAME_MN1,
}
bars = mt5.copy_rates_range(symbol, tf_to_mt[tf], utc_from, utc_to)
bars_df = pd.DataFrame(bars)
bars_df["time"] = pd.to_datetime(bars_df["time"], unit="s")
return bars_df
def get_stock_by_date(stocks, start_date, end_date, timeframe):
""" get prices between a start and end period """
data = None
for i, stock in enumerate(stocks):
#rates = mt5.copy_rates_from_pos(stock, timeframe, 0, bars)
rates = mt5.copy_rates_range(stock, timeframe, start_date, end_date)
rates_frame = pd.DataFrame(rates)
rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s')
rates_frame['stock'] = stock
if i == 0:
data = rates_frame
else:
data = data.append(rates_frame)
return data
def get_prices(self, symbol, from_date, to_date, timeframe):
"""
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
:param timeframe: The timeframe for the candes. Possible values are:
TIMEFRAME_M1: 1 minute
TIMEFRAME_M2: 2 minutes
TIMEFRAME_M3: 3 minutes
TIMEFRAME_M4: 4 minutes
TIMEFRAME_M5: 5 minutes
TIMEFRAME_M6: 6 minutes
TIMEFRAME_M10: 10 minutes
TIMEFRAME_M12: 12 minutes
TIMEFRAME_M15: 15 minutes
TIMEFRAME_M20: 20 minutes
TIMEFRAME_M30: 30 minutes
TIMEFRAME_H1: 1 hour
TIMEFRAME_H2: 2 hours
TIMEFRAME_H3: 3 hours
TIMEFRAME_H4: 4 hours
TIMEFRAME_H6: 6 hours
TIMEFRAME_H8: 8 hours
TIMEFRAME_H12: 12 hours
TIMEFRAME_D1: 1 day
TIMEFRAME_W1: 1 week
TIMEFRAME_MN1: 1 month
:return: Price data for symbol as dataframe
"""
prices_dataframe = None
# Get prices from MT5
prices = MetaTrader5.copy_rates_range(symbol, timeframe, from_date,
to_date)
if prices is not None:
self.__log.debug(f"{len(prices)} prices retrieved for {symbol}.")
# Create dataframe from data and convert time in seconds to datetime format
prices_dataframe = pd.DataFrame(prices)
prices_dataframe['time'] = pd.to_datetime(prices_dataframe['time'],
unit='s')
return prices_dataframe
def get_data(time_frame):
pairs = ['EURUSD', 'USDCAD']
pair_data = dict()
for pair in pairs:
utc_from = datetime(2021, 1, 1)
date_to = datetime.now().astimezone(pytz.timezone('America/New_York'))
date_to = datetime(
date_to.year, date_to.month, date_to.day,
hour=date_to.hour, minute=date_to.minute,
)
rates = mt5.copy_rates_range(pair, time_frame, utc_from, date_to)
rates_frame = pd.DataFrame(rates)
rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s')
rates_frame.drop(rates_frame.tail(1).index, inplace=True)
pair_data[pair] = rates_frame
return pair_data
def getrates(symbolstr, timeframe, datefrom, dateto):
"""
:param symbolstr: str
:param timeframe:
:param datefrom: str "%d-%m-%Y %H:%M"
:param dateto: str "%d-%m-%Y %H:%M"
:return:
"""
dfrom = datetime.datetime.strptime(datefrom, "%d-%m-%Y %H:%M")
dto = datetime.datetime.strptime(dateto, "%d-%m-%Y %H:%M")
rates = mt5.copy_rates_range(symbolstr, timeframe, dfrom, dto)
if rates == None:
return None
ratesadj = [[
datetime.datetime.fromtimestamp(r[0]), r[1], r[2], r[3], r[4], r[5],
r[6], r[7],
datetime.datetime.fromtimestamp(r[0]).date()
] for r in rates]
return ratesadj
def get_data(self, time_frame: int, begin: datetime, end: datetime):
"""fetch data to a given time_frame
Args:
time_frame (int): the required time frame
begin (datetime): The begin of the data to fetch
end (datetime): the end of the data to fetch
Returns:
dict: the data for all needed pairs
"""
# TODO: the array shouldn't be hard-coded and be passed as parameter
pairs = ['EURJPY']
pair_data = dict()
for pair in pairs:
rates = mt5.copy_rates_range(pair, time_frame, begin, end)
rates_frame = pd.DataFrame(rates)
rates_frame['time'] = pd.to_datetime(rates_frame['time'], unit='s')
rates_frame.drop(rates_frame.tail(1).index, inplace=True)
pair_data[pair] = rates_frame
return pair_data
