def test_default_calendars():
for name in get_calendar_names():
if name == "XKRX":
with pytest.warns(UserWarning):
assert get_calendar(name) is not None
else:
assert get_calendar(name) is not None
def market_open():
"""
Checks if markets are open
Returns:
True if markets are open
False if markets are closed
"""
currentDT = str(datetime.datetime.now().strftime("%Y-%m-%d"))
futureDT = str(datetime.datetime.now() + datetime.timedelta(days=+2))[:10]
dt_string = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
nyse = mcal.get_calendar('NYSE')
today_nyse = nyse.schedule(start_date=dt_string, end_date=dt_string)
open_nyse = nyse.open_at_time(today_nyse, pd.Timestamp(dt_string,
tz='UTC'))
lse = mcal.get_calendar('LSE')
today_lse = lse.schedule(start_date=dt_string, end_date=dt_string)
open_lse = lse.open_at_time(today_lse, pd.Timestamp(dt_string, tz='UTC'))
jpx = mcal.get_calendar('JPX')
today_jpx = jpx.schedule(start_date=currentDT, end_date=futureDT)
open_jpx = jpx.open_at_time(today_jpx, pd.Timestamp(dt_string, tz='UTC'))
print(f'\nChecking Market hours On: {dt_string} \nMarkets Open:')
print(f'Japan: {open_jpx}, London: {open_lse}, NY: {open_nyse}')
print(f'Trading time:{open_jpx or open_lse or open_nyse}')
return (open_jpx or open_lse or open_nyse)
def test_get_calendar():
assert isinstance(mcal.get_calendar('NYSE'), NYSEExchangeCalendar)
cal = mcal.get_calendar('NYSE', datetime.time(10, 0),
datetime.time(14, 30))
assert isinstance(cal, NYSEExchangeCalendar)
assert cal.open_time == datetime.time(10, 0)
assert cal.close_time == datetime.time(14, 30)
def getTradingDates():
"""Get all dates in the range that the NYSE was trading on."""
print("\nRETRIEVING TRADING DATES...\n")
# Days NYSE was open
trainingDates = (pandas_market_calendars.get_calendar('NYSE').valid_days(
start_date=Constants.trainingStartDate,
end_date=Constants.trainingEndDate)
)
testingDates = (pandas_market_calendars.get_calendar('NYSE').valid_days(
start_date=Constants.testingStartDate,
end_date=Constants.testingEndDate)
)
# Just save date (YYYY-MM-DD)
trainingDates = [day.date() for day in trainingDates]
testingDates = [day.date() for day in testingDates]
if Constants.missingDate in trainingDates:
trainingDates.remove(Constants.missingDate)
if Constants.missingDate in testingDates:
testingDates.remove(Constants.missingDate)
pk.dump(trainingDates, open(Constants.dataDir + "trainingDates.p", "wb"))
pk.dump(testingDates, open(Constants.dataDir + "testingDates.p", "wb"))
return trainingDates, testingDates
def __init__(self,
entity_type=EntityType.Stock,
exchanges=['NYSE', 'NASDAQ'],
entity_ids=None,
codes=None,
batch_size=10,
force_update=False,
sleeping_time=5,
default_size=2000,
real_time=False,
fix_duplicate_way='add',
start_timestamp=None,
end_timestamp=None,
close_hour=0,
close_minute=0,
share_para=None) -> None:
super().__init__(entity_type,
exchanges,
entity_ids, ['A'],
batch_size,
force_update,
sleeping_time,
default_size,
real_time,
fix_duplicate_way,
start_timestamp,
end_timestamp,
close_hour,
close_minute,
share_para=share_para)
self.nyse = mcal.get_calendar('NYSE')
self.nasdaq = mcal.get_calendar('NASDAQ')
def test_get_calendar():
assert isinstance(mcal.get_calendar('NYSE'), NYSEExchangeCalendar)
cal = mcal.get_calendar('NYSE', datetime.time(10, 0),
datetime.time(14, 30))
assert isinstance(cal, NYSEExchangeCalendar)
assert cal.open_time == datetime.time(10, 0)
assert cal.close_time == datetime.time(14, 30)
# confirm that import works properly
cal = mcal.get_calendar('CME')
def read(cls, rootdir):
path = cls.metadata_path(rootdir)
with open(path) as fp:
raw_data = json.load(fp)
try:
version = raw_data['version']
except KeyError:
# Version was first written with version 1, assume 0,
# if version does not match.
version = 0
default_ohlc_ratio = raw_data['ohlc_ratio']
if version >= 1:
minutes_per_day = raw_data['minutes_per_day']
else:
# version 0 always assumed US equities.
minutes_per_day = US_EQUITIES_MINUTES_PER_DAY
if version >= 2:
calendar = get_calendar(raw_data['calendar_name'])
start_session = pd.Timestamp(raw_data['start_session'],
tz='UTC')
end_session = pd.Timestamp(raw_data['end_session'], tz='UTC')
else:
# No calendar info included in older versions, so
# default to NYSE.
calendar = get_calendar('XNYS')
start_session = pd.Timestamp(raw_data['first_trading_day'],
tz='UTC')
end_session = calendar.minute_to_session_label(
pd.Timestamp(raw_data['market_closes'][-1],
unit='m',
tz='UTC'))
if version >= 3:
ohlc_ratios_per_sid = raw_data['ohlc_ratios_per_sid']
if ohlc_ratios_per_sid is not None:
ohlc_ratios_per_sid = keymap(int, ohlc_ratios_per_sid)
else:
ohlc_ratios_per_sid = None
return cls(
default_ohlc_ratio,
ohlc_ratios_per_sid,
calendar,
start_session,
end_session,
minutes_per_day,
version=version,
)
def plotPrediction(model, prices, scaled, start_date, hist_size, predict_size, mean, std, instrument = ['Equity', 'Future', 'Crypto'][0]):
if instrument == 'Equity':
nyse = mcal.get_calendar('NYSE').regular_holidays
holidays = [x.strftime("%Y-%m-%d") for x in nyse.holidays(start='2010-01-01', end='2023-12-31').to_list()]
beginDate_hist = np.busday_offset(start_date, -hist_size, holidays=holidays)
endDate_hist = np.busday_offset(start_date, -1, holidays=holidays)
endDate_future = np.busday_offset(start_date, predict_size - 1, holidays=holidays)
dates_future = [np.busday_offset(start_date, i, holidays=holidays) for i in range(0, predict_size)]
elif instrument == 'Future':
weekdays = "Mon Tue Wed Thu Fri Sun"
cme = mcal.get_calendar('CME').regular_holidays
holidays = [x.strftime("%Y-%m-%d") for x in cme.holidays(start='2010-01-01', end='2023-12-31').to_list()]
beginDate_hist = np.busday_offset(start_date, -hist_size, holidays=holidays, weekmask=weekdays)
endDate_hist = np.busday_offset(start_date, -1, holidays=holidays, weekmask=weekdays)
endDate_future = np.busday_offset(start_date, predict_size - 1, holidays=holidays, weekmask=weekdays)
dates_future = [np.busday_offset(start_date, i, holidays=holidays, weekmask=weekdays) for i in range(0, predict_size)]
else:
beginDate_hist = start_date - np.timedelta64(hist_size, 'D')
endDate_hist = start_date - np.timedelta64(1, 'D')
endDate_future = start_date + np.timedelta64(predict_size - 1, 'D')
dates_future = np.arange(start_date, start_date + np.timedelta64(predict_size, 'D'), step=np.timedelta64(1, 'D'))
# get scaled prices of history
past_scaled = scaled.loc[beginDate_hist: endDate_hist]
past_tensor = tf.convert_to_tensor(np.array(past_scaled).reshape(1, past_scaled.shape[0], past_scaled.shape[1]),
dtype=tf.float32)
# make predictions
predicted = np.array(model.predict(past_tensor)[0])
predicted_price = [(x * std) + mean for x in predicted]
# plot
trueHistClose = prices.loc[beginDate_hist:endDate_hist][['Close']].rename(columns = {'Close': 'Trailing Price'})
trueClose = prices.loc[endDate_hist:endDate_future][['Close']].rename(columns = {'Close': 'True Price'})
predClose = pd.DataFrame.from_dict({'date': dates_future, 'Predicted Price': predicted_price}).set_index('date')
joined = pd.concat([trueHistClose, trueClose, predClose], axis=1)
joined.loc[endDate_hist, 'Predicted Price'] = joined.loc[endDate_hist, 'True Price']
plt.figure()
joined.plot(figsize=(12,6),
title='Predictions: {} - {}'.format(dates_future[0], dates_future[-1]),
)
plt.xlabel('Date')
plt.ylabel('Price ($)')
plt.show()
return joined, predicted_price
def get_market_days(self, period=relativedelta(years=1)):
#will return a list of previous in perioddays that the market has been open up to the last valid day
x = mcal.get_calendar('NYSE').schedule(
start_date=datetime.now().date() - period,
end_date=datetime.strptime(self.get_last_complete_market_day(),
'%Y-%m-%d'))
return x.index.strftime('%Y-%m-%d') #return everything as strings
def current_valuation(value_date):
spy_data = spy_data_df()
'''Use value date as start date for model. Use mcal library to pull dates. Given start date, pulls trading days for entire year then chops so that only
24 trading days are utlized. Craft binomial tree from start date quant features.'''
end_date_year = str(value_date.year + 1)
end_date = pd.to_datetime(str(end_date_year + '/12/31'))
nyse = mcal.get_calendar('NYSE')
dates = [date.replace(tzinfo = None) for date in nyse.valid_days(start_date = value_date, end_date = end_date)[:24]]
valuation_tree_df = pd.DataFrame(columns = [dates], index = [i for i in range(24)])
valuation_tree_df[valuation_tree_df.columns[0]][0] = spy_data['Close'].loc[spy_data['Date'] == dates[0]].values[0]
for i in range(24):
if i == 0: continue
up_move_price = valuation_tree_df[valuation_tree_df.columns[i-1]][0]*spy_data['Up Move'].loc[spy_data['Date'] == dates[0]].values[0]
valuation_tree_df[valuation_tree_df.columns[i]][0] = up_move_price
for k in range(i):
down_move_price = valuation_tree_df[valuation_tree_df.columns[i-1]][k]*spy_data['Down Move'].loc[spy_data['Date'] == dates[0]].values[0]
valuation_tree_df[valuation_tree_df.columns[i]][k+1] = down_move_price
prob = []
for i in range(len(valuation_tree_df[valuation_tree_df.columns[-1]])):
prob.append(binom.pmf(23-i, len(valuation_tree_df[valuation_tree_df.columns[-1]])-1, spy_data['P(U)'].loc[spy_data['Date'] == dates[0]].values[0]))
prob_node_df = pd.DataFrame({'Predicted Price': valuation_tree_df[valuation_tree_df.columns[-1]], 'Probability': prob})
prob_node_df['Weighted Value'] = prob_node_df['Predicted Price']*prob_node_df['Probability']
return(prob_node_df['Weighted Value'].sum())
def get_all_bars(self, ticker_symbol, start_date, end_date):
# get a list of market opens and closes for each trading day from 2015 onwards
trading_days = mcal.get_calendar('NYSE').schedule(start_date, end_date)
# initialize an empty list of all bars
all_bars = []
# for each day in our list of trading days...
for i in range(len(trading_days)):
# get the time at the start of the request
request_time = time.time()
# get the list of bars for the next day
next_bars = self.get_date_bars(ticker_symbol,
trading_days['market_open'][i],
trading_days['market_close'][i])
# print a log statement
#TODO: Change to human readable format
print(
f'Got bars for {pd.to_datetime(next_bars[-1]["t"], unit="s")}')
# add the next bars to our growing list of all bars
all_bars += next_bars
# sleep to ensure that no more than 200 requests occur per 60 seconds
time.sleep(max(request_time + 60 / 200 - time.time(), 0))
# return the list of all bars
return all_bars
def test_filter_days(self):
provider = CsvFileDataProvider(["data"])
nyse = mcal.get_calendar('NYSE')
days = nyse.valid_days(start_date='2000-01-01', end_date='2017-01-01')
daily = provider.get_dataframes(
[SymbolData('DIS', 'day', 'day', '2000-01-01', '2017-01-01')])[0]
assert len(days) == len(daily)
def check_latest_data_sqlite():
update = False
# see if any db exists
path = os.path.expanduser(DB_LOC)
db_path = os.path.join(path, DB_NAME)
if os.path.exists(db_path):
conn = sqlite3.connect(db_path)
latest = get_latest_data_sqlite(conn)
conn.close()
# stonks market calendar
now = pd.datetime.now(pytz.timezone('US/Eastern'))
ndq = mcal.get_calendar('NASDAQ').schedule('2010-01-01', now)
ndq.market_close = ndq.market_close.dt.tz_convert('US/Eastern')
# if the latest trading day is after the latest date we have,
# and we are past the last day's close, update
if ndq.index.max().date() > latest.index[-1].date():
if ndq.iloc[-1].market_close < now:
update = True
else:
update = True
return update
def __init__(self, otype, S0, K, q=0, marketPrice=None, T=None, expDay=None, vol=None, r=0.025, ls='Long'):
self.S0=S0
self.K=K
self.r=r
self.otype=otype.title()
self.daysInYear = 252
self.q=q
self.ls = ls
if T is None and expDay is None:
print('Please enter days to expiry or expiration day')
elif T is None:
self.expDayStr = expDay
expDay = np.datetime64(expDay)
nyse = mcal.get_calendar('NYSE')
self.T= (np.busday_count(np.datetime64('today'), expDay, holidays=nyse.holidays().holidays)+1)/self.daysInYear
else:
self.T=T
if marketPrice is None and vol is None:
print('Please enter either market price or implied vol of option')
elif marketPrice is None:
self.vol=vol
self.marketPrice=self.price()
elif vol is None:
self.marketPrice=marketPrice
self.vol=self.IV()
def test_date_range_lower_freq():
cal = mcal.get_calendar("NYSE")
schedule = cal.schedule(pd.Timestamp('2017-09-05 20:00', tz='UTC'),
pd.Timestamp('2017-10-23 20:00', tz='UTC'))
# cannot get date range of frequency lower than 1D
with pytest.raises(ValueError) as e:
mcal.date_range(schedule, frequency='3D')
assert e.exconly(
) == "ValueError: Frequency must be 1D or higher frequency."
# instead get for 1D and convert to lower frequency
short = mcal.date_range(schedule, frequency='1D')
actual = mcal.convert_freq(short, '3D')
expected = pd.date_range('2017-09-05 20:00',
'2017-10-23 20:00',
freq='3D',
tz='UTC')
assert_index_equal(actual, expected)
actual = mcal.convert_freq(short, '1W')
expected = pd.date_range('2017-09-05 20:00',
'2017-10-23 20:00',
freq='1W',
tz='UTC')
assert_index_equal(actual, expected)
def __init__(self, start=None, end=None):
all_minute_loc = glob.glob(f'/home/dewe/samgame/datasets/minute/*')
self.sym_dict = {
s.split('\\')[-1].split('_')[0]: s
for s in all_minute_loc
}
if start and end:
nyse = mcal.get_calendar('NYSE')
early = nyse.schedule(start_date=start, end_date=end)
full_date_range = mcal.date_range(early,
frequency='1min').tz_convert(NY)
self.full_date_range = full_date_range
with open(
f'/home/dewe/samgame/datasets/dates_{start.year}_{end.year}.pkl',
'wb') as pkl:
pickle.dump(full_date_range, pkl)
else:
with open(f'/home/dewe/samgame/datasets/dates_2004_2020.pkl',
'rb') as pkl:
self.full_date_range = pickle.load(pkl)
self.all_syms = list(self.sym_dict.keys())
self.live_data = {}
self.tech_indicators = None
self.done = False
def create_market_cal(start, end):
nyse = mcal.get_calendar('NYSE')
schedule = nyse.schedule(stocks_start, stocks_end)
market_cal = mcal.date_range(schedule, frequency='1D')
market_cal = market_cal.tz_localize(None)
market_cal = [i.replace(hour=0) for i in market_cal]
return market_cal
def get_business_date_offset(business_date: date, days_offset: int):
'''
Returns the business date offest by 'days_offset' business date.
For example, the day before the observed 4th of July will return
the following Monday:
(2020/07/02, 1) -> 2020/07/06
if the business date is not valid, the method will throw a ValidationError
'''
nyse_cal = mcal.get_calendar('NYSE')
if days_offset > 0:
market_calendar = nyse_cal.schedule(
business_date,
business_date + timedelta(days=int(days_offset * 1.5)))
else:
market_calendar = nyse_cal.schedule(
business_date + timedelta(days=int(days_offset * 1.5)),
business_date)
# reverse the calendar order
market_calendar = market_calendar.iloc[::-1]
# if business_date is not valid, raise an exception
try:
market_calendar.index.get_loc(business_date)
except Exception as e:
raise ValidationError(
"Cannot offset %s by %d days because %s is not a valid business date"
% (business_date, days_offset, business_date), e)
return market_calendar.index[abs(days_offset)].to_pydatetime().date()
def get_market_schedule(self, market: str) -> MarketSchedule:
tz = pytz.timezone(self.local_tz)
exch_calendar = mcal.get_calendar(market)
schedule_df = exch_calendar.schedule(
self.scheduler.get_clock().get_start_time(tz),
self.scheduler.get_clock().get_end_time(tz))
class NullEvent(Event):
def on_activate(self) -> bool:
return True
market_open = NullEvent()
market_close = NullEvent()
for index, row in schedule_df.iterrows():
market_open_dt = row['market_open'].astimezone(tz)
market_close_dt = row['market_close'].astimezone(tz)
self.scheduler.get_network().attach(market_open)
self.scheduler.get_network().attach(market_close)
self.scheduler.schedule_event_at(
market_open, Clock.to_millis_time(market_open_dt))
self.scheduler.schedule_event_at(
market_close, Clock.to_millis_time(market_close_dt))
return MarketSchedule(schedule_df, market_open, market_close)
def market_open(now=None):
"""Is the market open?"""
nyse = mcal.get_calendar('NYSE')
if now is None:
now = arrow.now('America/New_York')
schedule = nyse.schedule(start_date=now.datetime, end_date=now.datetime)
return nyse.open_at_time(schedule, now.datetime) # Market currently open
def get_business_days_list(startdate, enddate):
nyse = mcal.get_calendar('NYSE')
business_days = nyse.valid_days(start_date=startdate, end_date=enddate).strftime('%Y-%m-%d')
date_list = []
for date in range(0, len(business_days) - 1):
date_list.append(business_days[date])
return date_list
def expected_index(df, exchange='nyse'):
exchange_dates = mcal.get_calendar(name=exchange.upper())
exchange_dates = exchange_dates.schedule(start_date=df.index[0],
end_date=df.index[-1])
return exchange_dates.index
def generate_data(ticker_list, start_date='2000-01-01', end_date='2010-01-01'):
# Create a calendar
nyse = mcal.get_calendar('NYSE')
dates = nyse.schedule(start_date=start_date, end_date=end_date)
dates['date'] = dates['market_open'].dt.date
df = pd.DataFrame(index=range(len(dates['date'])))
df = df.reset_index()
df.index = dates['date']
for ticker in ticker_list:
a = np.random.uniform(1, 1000)
b = np.random.uniform(0.05, 1)
c = np.random.uniform(0.1, .4)
d = np.random.uniform(0.1, (a - b) / 20)
e = np.random.uniform(-0.03, 0.08)
f = np.random.uniform(10, 25)
g = np.random.uniform(0.003, 0.008)
shift1 = np.random.uniform(0, 2 * math.pi)
shift2 = np.random.uniform(0, 2 * math.pi)
df[ticker] = np.maximum(
a + b * np.sin(c * df['index'] + shift1) +
np.random.normal(loc=0, scale=d, size=len(df['index'])) +
e * df['index'] + f * np.sin(g * df['index'] + shift2), 0.01)
df = df[df.columns[1:]] # get rid of index col
return df
def non_market_days_removal(ts, calendar_name='NYSE'):
"""
This function removes week end and holidays from time series index
:param ts: input time series with daily frequency
:param calendar_name: a calendar name from the list at
https://pandas-market-calendars.readthedocs.io/en/latest/calendars.html
:return: a time series where all the days are all market days according to selected calendar
"""
# retrieving calendar
calendar = mcal.get_calendar(calendar_name)
# retrieving calendar schedule
schedule = calendar.schedule(start_date=ts.index[0], end_date=ts.index[-1])
# fixing index within the the date range
ts.index = calendar.date_range(schedule, frequency='1D')
return ts
for i, d in enumerate(ts):
week_day_num = d.index.day().weekday()
if week_day_num > 5:
delta = datetime.timedelta((8 - week_day_num))
ts.index[i] = d.index + delta
already_used_days.append(d.index[i])
else:
ts.index[i], already_used_days = adjust_week_day(ts.index[i], already_used_days)
return ts
def get_data(config, stock_file_name='000002.SS'):
data_dir = config['data_dir']
start_time = config['start_time']
end_time = config['end_time']
time_col = config['time_col']
time_col = time_col[0]
data_file_path = f'{data_dir}/{stock_file_name}.csv'
if os.path.exists(data_file_path):
df_org = pd.read_csv(data_file_path, parse_dates=[time_col])
df_org = df_org.sort_values('<DTYYYYMMDD>')
df_org = df_org.set_index('<DTYYYYMMDD>')
df_org = df_org.tz_localize(None)
# Do fill missing day
stock_calendar = mcal.get_calendar('stock')
stock_time = stock_calendar.valid_days(
start_date=df_org.index.values[0],
end_date=df_org.index.values[-1])
stock_time.tz_localize(None)
df_time = pd.DataFrame((stock_time), columns=['<DTYYYYMMDD>'])
df_time = df_time.sort_values('<DTYYYYMMDD>')
df_time = df_time.set_index('<DTYYYYMMDD>')
df_time = df_time.tz_convert(None)
df_org = df_org.join(df_time, how='right')
df_org = df_org.fillna(method='backfill')
# df_org = df_org[np.logical_and(df_org[time_col].dt.to_pydatetime() >= config['start_time'], df_org[time_col].dt.to_pydatetime() <= config['end_time'])]
else:
return None
df_org = df_org.sort_values(time_col)
df_org.reset_index(inplace=True)
return df_org
def validateWorkingDays(startDate, endDate,companyTicker,company_name):
nyse = mcal.get_calendar('NYSE')
isValidWorkingDays = False
isvaliddate = nyse.valid_days(startDate, endDate)
if ((abs(endDate-startDate).days)) <= 1:
start_Day = calendar.day_name[startDate.weekday()]
end_Day = calendar.day_name[endDate.weekday()]
if( (start_Day == "Saturday" and end_Day=="Sunday") or (start_Day == "Saturday" and end_Day=="Saturday") or (start_Day == "Sunday" and end_Day=="Sunday")):
print("The Day of end Date:", end_Day)
print("The Day of start Date:", start_Day)
isValidWorkingDays = False
elif((pd.Timestamp(startDate) not in isvaliddate) and (pd.Timestamp(endDate) not in isvaliddate)):
isValidWorkingDays = False
else:
isValidWorkingDays = True
else:
isValidWorkingDays = True
if(isValidWorkingDays):
getdata(startDate,endDate,companyTicker,company_name)
def load_bar_data(
self,
symbol: str,
exchange: Exchange,
interval: Interval,
start: datetime,
end: datetime,
) -> Sequence[BarData]:
calendar_name = EXCHANGE_CALENDAR[exchange]
calendar = get_calendar(calendar_name)
start_date = pd.Timestamp(start).tz_convert(pytz.utc)
end_date = pd.Timestamp(end).tz_convert(pytz.utc)
# start_session = minute_to_session_label(calendar, start)
# end_session = minute_to_session_label(calendar, end)
pair = get_date_range(calendar, start_date, end_date)
final_data = []
fields = self.class_bar.fields
for p in pair:
year = p[0].year
try:
meta = self.bcolz_meta.get(self.bcolz_meta.symbol==symbol, self.bcolz_meta.exchange==exchange.value, self.bcolz_meta.year==year)
meta_inst = BcolzMinuteBarMetadata.open(meta)
reader = BcolzMinuteBarReader(self.store_path, meta_inst)
start_session = p[0] if p[0] >= reader.first_dt() else reader.first_dt()
end_session = p[1] if p[1] < reader.last_dt() else reader.last_dt()
result = reader.load_raw_arrays(fields, start_session, end_session, [meta.sid])
print(result)
except Exception as e:
print(e)
return final_data
def __init__(self, chains):
self.logger = logging.getLogger(__name__)
# Internal Strategy Variables
self.date = self.datas[0].datetime.date # Reference
self.order = None # To keep track of pending orders
# Future Chains
self.chains = chains
self.names = {}
for idx, fc in enumerate(self.chains):
names = [n for n in self.getdatanames() if n[:2] == fc.stem]
self.chains[idx] = fc.filter_chain(names)
self.names[fc] = names
self.log(logging.INFO, 'Symbols per chain: {}'.format(self.names))
# Internals
self.calendars = {}
self.exits = {}
for fc in self.chains:
# Calendar
start, end = fc.get_start_end(extra_days=True)
# TODO: Get proper exchange! NYSE covers all american holidays!
self.calendars[fc] = pmc.get_calendar('NYSE').valid_days(
start, end)
# Exits
self.exits[fc] = ore.get_dates(ore.Events.LastDay,
self.calendars[fc], fc.chain, -2)
def check_if_today_trading_day():
today_ny = datetime.datetime.now(pytz.timezone('America/New_York'))
ndq = mcal.get_calendar('NASDAQ')
open_days = ndq.schedule(start_date=today_ny -
pd.Timedelta(str(365) + ' days'),
end_date=today_ny)
return open_days.index[-1].date() == today_ny.date()
def create_day_start_df(date, minutes):
# get data path
data_prefix = get_stonk_project_path() + '\\data\\raw_data_'
# get previous trading day
nyse = mcal.get_calendar('NYSE')
dates = [
date.strftime('%Y-%m-%d')
for date in nyse.schedule(start_date='2020-08-01',
end_date='2020-08-27').index
]
previous_date = dates[dates.index(date) - 1]
output_df = pd.DataFrame()
for minute in range(390 - minutes, 390):
# append a minute of data to the output
minute_df = pd.read_parquet(data_prefix + previous_date + '\\Minute=' +
str(minute))
output_df = output_df.append(minute_df)
# append the first minute of today
minute_df = pd.read_parquet(data_prefix + date + '\\Minute=0')
output_df = output_df.append(minute_df)
return (output_df)
def __init__(self):
self._calendar = self.p.calendar
if isinstance(self._calendar, string_types): # use passed mkt name
import pandas_market_calendars as mcal
self._calendar = mcal.get_calendar(self._calendar)
import pandas as pd # guaranteed because of pandas_market_calendars
self.dcache = pd.DatetimeIndex([0.0])
self.idcache = pd.DataFrame(index=pd.DatetimeIndex([0.0]))
self.csize = timedelta(days=self.p.cachesize)
