def test_years(self):
self.assertEqual(len(self.holidays.years), 0)
self.assertNotIn(date(2014, 1, 2), self.holidays)
self.assertEqual(len(self.holidays.years), 1)
self.assertIn(2014, self.holidays.years)
self.assertNotIn(date(2013, 1, 2), self.holidays)
self.assertNotIn(date(2014, 1, 2), self.holidays)
self.assertNotIn(date(2015, 1, 2), self.holidays)
self.assertEqual(len(self.holidays.years), 3)
self.assertIn(2013, self.holidays.years)
self.assertIn(2015, self.holidays.years)
self.holidays = holidays.US(years=range(2010, 2015 + 1))
self.assertEqual(len(self.holidays.years), 6)
self.assertNotIn(2009, self.holidays.years)
self.assertIn(2010, self.holidays.years)
self.assertIn(2015, self.holidays.years)
self.assertNotIn(2016, self.holidays.years)
self.holidays = holidays.US(years=(2013, 2015, 2015))
self.assertEqual(len(self.holidays.years), 2)
self.assertIn(2013, self.holidays.years)
self.assertNotIn(2014, self.holidays.years)
self.assertIn(2015, self.holidays.years)
self.assertIn(date(2021, 12, 31), holidays.US(years=[2022]).keys())
self.holidays = holidays.US(years=2015)
self.assertNotIn(2014, self.holidays.years)
self.assertIn(2015, self.holidays.years)
def get_start_date(self, past_months):
"""
Returns the date user wants to start collecting information.
:param past_months: number of months back user wants to research
"""
current_date = list(self.stock_dates.keys())[
0] # Gets most current day of the stock market
year = int(current_date[:4])
month = int(current_date[5:7])
day = int(current_date[8:10])
begin_date = date(year, month, day) - relativedelta(months=past_months)
year = begin_date.year
month = begin_date.month
day = begin_date.day
# Changes single digit to double.
if len(str(month)) is 1:
month = "0" + str(month)
if len(str(day)) is 1:
day = "0" + str(day)
# Date changes format.
start_date = str(year) + "-" + str(month) + "-" + str(day)
# Checks to make sure start date is a business day, if not moves to next business day.
if not isbday(start_date, holidays=holidays.US()):
start_date += relativedelta(bdays=+1, holidays=holidays.US())
return str(start_date)[:10]
def test_inauguration_day(self):
name = "Inauguration Day"
dc_holidays = holidays.US(state="DC")
la_holidays = holidays.US(state="LA")
md_holidays = holidays.US(state="MD")
va_holidays = holidays.US(state="VA")
for year in (1789, 1793, 1877, 1929, 1933):
self.assertNotIn(name, self.holidays.get_list(date(year, 3, 4)))
self.assertIn(name, dc_holidays.get_list(date(year, 3, 4)))
self.assertIn(name, la_holidays.get_list(date(year, 3, 4)))
self.assertIn(name, md_holidays.get_list(date(year, 3, 4)))
self.assertIn(name, va_holidays.get_list(date(year, 3, 4)))
for year in (1937, 1941, 1957, 2013, 2017):
self.assertNotIn(name, self.holidays.get_list(date(year, 1, 20)))
self.assertIn(name, dc_holidays.get_list(date(year, 1, 20)))
self.assertIn(name, la_holidays.get_list(date(year, 1, 20)))
self.assertIn(name, md_holidays.get_list(date(year, 1, 20)))
self.assertIn(name, va_holidays.get_list(date(year, 1, 20)))
for year in (1785, 1788, 2010, 2011, 2012, 2014, 2015, 2016):
self.assertNotIn(name, dc_holidays.get_list(date(year, 3, 4)))
self.assertNotIn(name, la_holidays.get_list(date(year, 3, 4)))
self.assertNotIn(name, md_holidays.get_list(date(year, 3, 4)))
self.assertNotIn(name, va_holidays.get_list(date(year, 3, 4)))
self.assertNotIn(name, dc_holidays.get_list(date(year, 1, 20)))
self.assertNotIn(name, la_holidays.get_list(date(year, 1, 20)))
self.assertNotIn(name, md_holidays.get_list(date(year, 1, 20)))
self.assertNotIn(name, va_holidays.get_list(date(year, 1, 20)))
def test_confederate_memorial_day(self):
al_holidays = holidays.US(state="AL")
ga_holidays = holidays.US(state="GA")
ms_holidays = holidays.US(state="MS")
sc_holidays = holidays.US(state="SC")
tx_holidays = holidays.US(state="TX")
self.assertNotIn(date(1865, 4, 24), self.holidays)
self.assertNotIn(date(1865, 4, 24), al_holidays)
for dt in [
date(1866, 4, 23),
date(1878, 4, 22),
date(1884, 4, 28),
date(2014, 4, 28),
date(2015, 4, 27),
date(2019, 4, 22),
]:
self.assertNotIn(dt, self.holidays)
self.assertIn(dt, al_holidays)
self.assertIn(dt, ga_holidays)
self.assertIn(dt, ms_holidays)
self.assertIn(dt, sc_holidays)
self.assertNotIn(date(1930, 1, 19), tx_holidays)
self.assertNotIn(date(1931, 1, 19), self.holidays)
self.assertIn(date(1931, 1, 19), tx_holidays)
self.assertIn(date(2020, 4, 10), ga_holidays)
def test_day_after_christmas(self):
nc_holidays = holidays.US(state="NC", observed=False)
tx_holidays = holidays.US(state="TX", observed=False)
self.assertNotIn(date(2015, 12, 28), nc_holidays)
self.assertNotIn(date(2016, 12, 27), nc_holidays)
self.assertNotIn(date(2015, 12, 28), tx_holidays)
self.assertNotIn(date(2016, 12, 27), tx_holidays)
nc_holidays.observed = True
self.assertIn(
"Day After Christmas (Observed)",
nc_holidays.get_list(date(2015, 12, 28)),
)
self.assertIn(
"Day After Christmas (Observed)",
nc_holidays.get_list(date(2016, 12, 27)),
)
tx_holidays.observed = True
self.assertNotIn(
"Day After Christmas (Observed)",
tx_holidays.get_list(date(2015, 12, 28)),
)
self.assertNotIn(
"Day After Christmas (Observed)",
tx_holidays.get_list(date(2016, 12, 27)),
)
def test_veterans_day(self):
for dt in [
date(1938, 11, 11),
date(1939, 11, 11),
date(1970, 11, 11),
date(1971, 10, 25),
date(1977, 10, 24),
date(1978, 11, 11),
date(2012, 11, 11),
date(2013, 11, 11),
date(2014, 11, 11),
date(2015, 11, 11),
date(2016, 11, 11),
date(2020, 11, 11)
]:
self.assertTrue(dt in self.holidays)
self.assertFalse(dt + relativedelta(days=-1) in self.holidays)
self.assertFalse(dt + relativedelta(days=+1) in self.holidays)
self.assertFalse("Armistice Day" in holidays.US(years=[1937]).values())
self.assertFalse("Armistice Day" in holidays.US(years=[1937]).values())
self.assertTrue("Armistice Day" in holidays.US(years=[1938]).values())
self.assertTrue("Armistice Day" in holidays.US(years=[1953]).values())
self.assertTrue("Veterans Day" in holidays.US(years=[1954]).values())
self.assertFalse(date(2012, 11, 12) in self.holidays)
self.assertFalse(date(2017, 11, 10) in self.holidays)
self.holidays.observed = True
self.assertTrue(date(2012, 11, 12) in self.holidays)
self.assertTrue(date(2017, 11, 10) in self.holidays)
def last_business_day(start_date, country='NA'):
'''
Purpose
-------
return the latest date before start_date that is a trading day in country
Parameters
----------
start_date : datetime or date object
the starting point from which we get the trading day
country : str, optional
the country concerned. this has impact on holidays. the default is 'NA',
which includes canada and usa. other examples include 'USD' or 'CAD'
Returns
-------
datetime object
'''
relevant_years = [start_date.year - 1, start_date.year]
if country == 'NA':
relevant_holidays = holidays.CA(years=relevant_years) + holidays.US(years=relevant_years)
elif country == 'CAD':
relevant_holidays = holidays.CA(years=relevant_years)
elif country == 'USD':
relevant_holidays = holidays.US(years=relevant_years)
date_inc = start_date
while (date_inc in relevant_holidays) or (date_inc.weekday() >= 5):
date_inc = date_inc - timedelta(days=1)
return date_inc
def get_duration_in_weeks(duration):
''' get start, end date for a week '''
today = get_today()
no_of_days = duration * 5 if duration > 0 else 2
end_day = today + relativedelta(bdays=-1, holidays=holidays.US())
start_day = today + relativedelta(bdays=-1 * no_of_days,
holidays=holidays.US())
return (str(start_day), str(end_day))
def test_add(self):
ca = holidays.CA()
us = holidays.US()
mx = holidays.MX()
na = ca + (us + mx)
self.assertFalse('2014-07-01' in us)
self.assertTrue('2014-07-01' in ca)
self.assertFalse('2014-07-04' in ca)
self.assertTrue('2014-07-04' in us)
self.assertTrue('2014-07-04' in ca + us)
self.assertTrue('2014-07-04' in us + ca)
self.assertTrue('2015-07-04' in ca + us)
self.assertTrue('2015-07-04' in us + ca)
self.assertTrue('2015-07-01' in ca + us)
self.assertTrue('2015-07-01' in us + ca)
self.assertTrue('2014-07-04' in na)
self.assertTrue('2015-07-04' in na)
self.assertTrue('2015-07-01' in na)
self.assertTrue('2000-02-05' in na)
self.assertEqual((ca + us).prov, 'ON')
self.assertEqual((us + ca).prov, 'ON')
ca = holidays.CA(years=[2014], expand=False)
us = holidays.US(years=[2014, 2015], expand=True)
self.assertFalse((ca + us).expand)
self.assertTrue((us + ca).expand)
self.assertEqual((ca + us).years, set([2014, 2015]))
self.assertEqual((us + ca).years, set([2014, 2015]))
na = holidays.CA()
na += holidays.US()
na += holidays.MX()
self.assertTrue('2014-07-04' in na)
self.assertTrue('2014-07-04' in na)
self.assertTrue('2015-07-04' in na)
self.assertTrue('2015-07-04' in na)
self.assertTrue('2015-07-01' in na)
self.assertTrue('2015-07-01' in na)
self.assertTrue('2000-02-05' in na)
self.assertEqual(na.prov, 'ON')
na = holidays.CA() + holidays.US()
na += holidays.MX()
self.assertTrue('2014-07-04' in na)
self.assertTrue('2014-07-04' in na)
self.assertTrue('2015-07-04' in na)
self.assertTrue('2015-07-04' in na)
self.assertTrue('2015-07-01' in na)
self.assertTrue('2015-07-01' in na)
self.assertTrue('2000-02-05' in na)
self.assertEqual(na.prov, 'ON')
self.assertRaises(TypeError, lambda: holidays.US() + {})
na = ca + (us + mx) + ca + (mx + us + holidays.CA(prov='BC'))
self.assertTrue('2000-02-05' in na)
self.assertTrue('2014-02-10' in na)
self.assertTrue('2014-02-17' in na)
self.assertTrue('2014-07-04' in na)
def test_martin_luther(self):
for dt in [
date(1986, 1, 20),
date(1999, 1, 18),
date(2000, 1, 17),
date(2012, 1, 16),
date(2013, 1, 21),
date(2014, 1, 20),
date(2015, 1, 19),
date(2016, 1, 18),
date(2020, 1, 20),
]:
self.assertIn(dt, self.holidays)
self.assertNotIn(dt + relativedelta(days=-1), self.holidays)
self.assertNotIn(dt + relativedelta(days=+1), self.holidays)
self.assertNotIn(
"Martin Luther King Jr. Day", holidays.US(years=[1985]).values()
)
self.assertIn(
"Martin Luther King Jr. Day", holidays.US(years=[1986]).values()
)
self.assertEqual(
holidays.US(state="AL").get("2015-01-19"),
"Robert E. Lee/Martin Luther King Birthday",
)
self.assertEqual(
holidays.US(state="AR").get("2015-01-19"),
("Dr. Martin Luther King Jr. " "and Robert E. Lee's Birthdays"),
)
self.assertEqual(
holidays.US(state="MS").get("2015-01-19"),
("Dr. Martin Luther King Jr. " "and Robert E. Lee's Birthdays"),
)
self.assertEqual(
holidays.US(state="AZ").get("2015-01-19"),
"Dr. Martin Luther King Jr./Civil Rights Day",
)
self.assertEqual(
holidays.US(state="NH").get("2015-01-19"),
"Dr. Martin Luther King Jr./Civil Rights Day",
)
self.assertEqual(
holidays.US(state="ID").get("2015-01-19"),
"Martin Luther King Jr. - Idaho Human Rights Day",
)
self.assertNotEqual(
holidays.US(state="ID").get("2000-01-17"),
"Martin Luther King Jr. - Idaho Human Rights Day",
)
self.assertEqual(
holidays.US(state="GA").get("2011-01-17"),
"Robert E. Lee's Birthday",
)
def test_new_years_eve(self):
ky_holidays = holidays.US(state="KY")
mi_holidays = holidays.US(state="MI")
wi_holidays = holidays.US(state="WI")
self.assertNotIn(date(2012, 12, 31), ky_holidays)
self.assertNotIn(date(2012, 12, 31), mi_holidays)
self.assertNotIn(date(2011, 12, 31), wi_holidays)
self.assertIn(date(2012, 12, 31), wi_holidays)
for dt in [date(2013, 12, 31), date(2016, 12, 30)]:
self.assertNotIn(dt, self.holidays)
self.assertIn(dt, ky_holidays)
self.assertIn(dt, mi_holidays)
self.assertIn(dt, wi_holidays)
def test_cesar_chavez_day(self):
ca_holidays = holidays.US(state="CA")
tx_holidays = holidays.US(state="TX")
for year in range(1995, 2000):
self.assertNotIn(date(year, 3, 31), self.holidays)
self.assertIn(date(year, 3, 31), ca_holidays)
for year in range(2000, 2020):
self.assertNotIn(date(year, 3, 31), self.holidays)
self.assertIn(date(year, 3, 31), ca_holidays)
self.assertIn(date(year, 3, 31), tx_holidays)
for year in (1996, 2002, 2013, 2019):
self.assertNotIn(date(year, 4, 1), self.holidays)
self.assertIn(date(year, 4, 1), ca_holidays)
self.assertNotIn(date(year, 4, 1), tx_holidays)
def next_business_day(x):
if x == '':
ONE_DAY = datetime.timedelta(days=1)
HOLIDAYS_US = holidays.US()
next_day = datetime.date.today() + ONE_DAY
while next_day.weekday() in holidays.WEEKEND or next_day in HOLIDAYS_US:
next_day += ONE_DAY
return next_day
else:
ONE_DAY = datetime.timedelta(days=x)
HOLIDAYS_US = holidays.US()
next_day = datetime.today() + ONE_DAY
while next_day.weekday() in holidays.WEEKEND or next_day in HOLIDAYS_US:
next_day += ONE_DAY
return next_day
def handleHoliday(self, intent, mic):
print("handleHoliday")
print(intent)
CurrentYear = datetime.datetime.today().year
if 'HolidayKeyword' in intent['matches']:
for holiday in intent['matches']['HolidayKeyword']:
dateslist = holidays.US(years=[CurrentYear]).get_named(holiday)
if len(dateslist):
for date in dateslist:
if (date < datetime.date.today()):
mic.say(
self.gettext(
"THIS YEAR, {} WILL BE ON {}").format(
holiday, str(date)))
elif (date == datetime.date.today()):
mic.say(
self.gettext("TODAY IS {}").format(holiday))
else:
mic.say(
self.gettext(
"THIS YEAR, {} WILL BE ON {}").format(
holiday, str(date)))
else:
mic.say(self.gettext("ERROR FINDING HOLIDAY"))
return True
def previous_working_day(check_day_, holidays=holidays.US()):
offset = max(1, (check_day_.weekday() + 6) % 7 - 3)
most_recent = check_day_ - dt.timedelta(offset)
if most_recent not in holidays:
return most_recent
else:
return previous_working_day(most_recent, holidays)
def get_holidays(custom_days, year):
import holidays
holiday_dict = holidays.US(years=year)
custom_holiday_dict = holidays.HolidayBase()
custom_holiday_dict.append(custom_days)
holiday_list = []
date_list = []
for i in holiday_dict.items():
date_list.append(i[0])
holiday_list.append(i[1])
df_a = pd.DataFrame({'ds': date_list, 'holiday': holiday_list})
custom_holiday_list = []
custom_date_list = []
for i in custom_holiday_dict.items():
custom_date_list.append(i[0])
custom_holiday_list.append(i[1])
df_b = pd.DataFrame({
'ds': custom_date_list,
'holiday': custom_holiday_list
})
holiday_df = pd.concat([df_a, df_b])
holiday_df.reset_index(drop=True)
return holiday_df.sort_values(by='ds')
def test_readme(self):
workday = WorkDayRule(start_time=datetime.time(9),
end_time=datetime.time(18),
working_days=[0, 1, 2, 3, 4],
tz=pytz.utc)
lunchbreak = LunchTimeRule(start_time=datetime.time(12),
end_time=datetime.time(13),
working_days=[0, 1, 2, 3, 4])
businesshrs = Rules([workday, lunchbreak])
start = datetime.datetime(2016, 1, 18, 9, 0, 0)
end = datetime.datetime(2016, 1, 25, 9, 0, 0)
bdiff = businesshrs.difference(start, end)
self.assertEqual(bdiff.hours, 40)
self.assertEqual(bdiff.seconds, 0)
self.assertEqual(str(start + BusinessTimeDelta(businesshrs, hours=40)),
"2016-01-22 18:00:00+00:00")
self.assertEqual(str(end - BusinessTimeDelta(businesshrs, hours=40)),
"2016-01-18 09:00:00+00:00")
ca_holidays = pyholidays.US(state='CA')
holidays = HolidayRule(ca_holidays)
businesshrs = Rules([workday, lunchbreak, holidays])
start = datetime.datetime(2015, 12, 21, 9, 0, 0)
end = datetime.datetime(2015, 12, 28, 9, 0, 0)
bdiff = businesshrs.difference(start, end)
self.assertEqual(bdiff.hours, 32)
self.assertEqual(bdiff.seconds, 0)
def get_hours(self) -> int:
workday = businesstimedelta.WorkDayRule(start_time=dt.time(
9), end_time=dt.time(17), working_days=[0, 1, 2, 3, 4])
ma_holidays = pyholidays.US(state="MA")
holidays = businesstimedelta.HolidayRule(ma_holidays)
business_hrs = businesstimedelta.Rules([workday, holidays])
return business_hrs.difference(self.start_date, self.end_date).hours
def holidays_list(self, year):
holidays_list = holidays.US(years=year)
holidays_dict = {}
for day in holidays_list:
holiday = {'start': day - timedelta(days=2), 'end': day + timedelta(days=2)}
holidays_dict[day.strftime("%Y-%m-%d")] = holiday
return holidays_dict
def GetHolidays(profile, context):
now = datetime.datetime.now()
upcoming = []
for date, name in sorted(holidays.US(state='NJ', years=2017).items()):
if date > now.date():
upcoming.append(name)
context['holidays'] = upcoming
def test_get_list(self):
westland = holidays.NZ(prov="WTL")
chathams = holidays.NZ(prov="CIT")
wild = westland + chathams
self.assertEqual(
wild[date(1969, 12, 1)],
("Westland Anniversary Day, " + "Chatham Islands Anniversary Day"),
)
self.assertEqual(
wild.get_list(date(1969, 12, 1)),
["Westland Anniversary Day", "Chatham Islands Anniversary Day"],
)
self.assertEqual(wild.get_list(date(1969, 1, 1)), ["New Year's Day"])
self.assertEqual(westland.get_list(date(1969, 12, 1)),
["Westland Anniversary Day"])
self.assertEqual(westland.get_list(date(1969, 1, 1)),
["New Year's Day"])
self.assertEqual(
chathams.get_list(date(1969, 12, 1)),
["Chatham Islands Anniversary Day"],
)
self.assertEqual(chathams.get_list(date(1969, 1, 1)),
["New Year's Day"])
ca = holidays.CA()
us = holidays.US()
mx = holidays.MX()
na = ca + us + mx
self.assertIn(date(1969, 12, 25), na)
self.assertEqual(
na.get_list(date(1969, 12, 25)),
["Christmas Day", "Navidad [Christmas]"],
)
self.assertEqual(na.get_list(date(1969, 7, 1)), ["Dominion Day"])
self.assertEqual(na.get_list(date(1969, 1, 3)), [])
def working_duration(start_unix, end_unix):
''' Determine working duration (working hours only)
Keyword arguments:
start_unix: start time (epoch seconds)
end_unix: end time (epoch seconds)
'''
open_time = datetime.time(6, 0, 0)
close_time = datetime.time(18, 0, 0)
holidaylist = pyholidays.US()
startstring = time.strftime('%Y-%m-%d %H:%M:%S',
time.localtime(start_unix))
endstring = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(end_unix))
startdate = pd.to_datetime(startstring)
enddate = pd.to_datetime(endstring)
work_duration = businessDuration(startdate,
enddate,
open_time,
close_time,
holidaylist=holidaylist,
unit='hour') * 3600
try:
work_duration = int(work_duration)
except ValueError as err:
print(str(err) + ' for ' + startstring + ', ' + endstring)
work_duration = end_unix - start_unix
return work_duration
def __init__(self, sample_buildings=500, modeling_hours=1000):
# Inputs
# random.seed(123)
self.building_classes = 25 # building class
self.total_buildings = 815032 # building parcels
self.sample_buildings = sample_buildings
self.doe_archetypes = 19 # building archetypes
self.total_hours = 8784 # hours in a year
self.modeling_hours = modeling_hours # hours to model
# Load Files and store as np arrays
self.m = pd.read_csv('/Users/jonathanroth/PycharmProjects/UBEM/M.csv').values[:, 1:].astype(float) # [self.building_classes x K]
self.a = pd.read_csv('/Users/jonathanroth/PycharmProjects/UBEM/A.csv').values[:, 2:].astype(float) # [self.sample_buildings x self.building_classes]
self.pluto_export = pd.read_csv('/Users/jonathanroth/PycharmProjects/UBEM/Pluto_export.csv')
self.building_energy = self.pluto_export['Energy_kbtu'].values.astype(float)
self.nyc_8784_electricity= pd.read_csv('/Users/jonathanroth/PycharmProjects/UBEM/NYC_8784_ElectricityUse.csv')
self.city_electricity = self.nyc_8784_electricity['Load'].values.astype('float')
self.city_electricity_scaled = self.city_electricity / np.mean(self.city_electricity[:self.total_hours])
self.doe_ref_buildings = pd.read_csv('/Users/jonathanroth/PycharmProjects/UBEM/DOE_RefBuildings.csv')
self.temperature = self.doe_ref_buildings['Temperature'].values.astype(float).reshape((self.total_hours, 1))
self.cdd = self.doe_ref_buildings['Cooling_Degree_Hour'].values.astype(float).reshape((self.total_hours, 1))
self.date_time = self.doe_ref_buildings['Date_Time'].values.astype(str).reshape((self.total_hours, 1))
self.bday = np.array([isbday(self.date_time[i, 0][0:10], holidays=holidays.US())
for i in range(len(self.date_time))]).astype(int) # TODO
# MANUAL SCALING and X matrix
self.sf = 0.5
self.x = np.zeros([self.doe_archetypes, self.doe_archetypes, self.total_hours]).astype(float)
for k in range(self.doe_archetypes):
self.x[k, k, :] = self.doe_ref_buildings.values[:, k + 2]
self.x[k, k, :] = self.sf * (self.x[k, k, :]) / np.mean(self.x[k, k, :self.total_hours]) + (1 - self.sf)
print('Shape of X: ', np.shape(self.x))
def datetime_ft(self,ft):
temp = pd.to_datetime(ft['pickup_datetime'])
ft['month'] = temp.dt.month
print temp
# 提取星期特征
ft['day'] = temp.dt.dayofweek
# 提取时、分、秒特征
ft['hour'] = temp.dt.hour
ft['minute'] = temp.dt.minute
ft['second'] = temp.dt.second
# 是否是假期
# for date, name in sorted(holidays.US(state='NY', years=2016).items()):
# print date, name
l = temp.dt.date.as_matrix()
h = holidays.US(state="NY")
holi = []
for i in l:
if i in h:
holi.append(1)
else:
holi.append(0)
ft["holi"] = holi
return ft
def __init__(self,
event_buffer: EventBuffer,
topology: Optional[str],
start_tick: int,
max_tick: int,
snapshot_resolution: int,
max_snapshots: Optional[int],
additional_options: dict = {}):
super().__init__("citi_bike", event_buffer, topology, start_tick,
max_tick, snapshot_resolution, max_snapshots,
additional_options)
# Trip binary reader.
self._trip_reader: BinaryReader = None
# Update self._config_path with current file path.
self.update_config_root_path(__file__)
# Holidays for US, as we are using NY data.
self._us_holidays = holidays.US()
# Our stations list used for quick accessing.
self._stations: List[Station] = []
self._total_trips: int = 0
self._total_shortages: int = 0
self._total_operate_num: int = 0
self._init()
def is_holidays(datetime_to_departure, airport_code):
if datetime_to_departure in holi.US(state=states[airport_code],
years=datetime_to_departure.year):
return 1
else:
return 0
def test_setitem(self):
self.holidays = holidays.US(years=[2014])
self.assertEqual(len(self.holidays), 10)
self.holidays[date(2014, 1, 3)] = "Fake Holiday"
self.assertEqual(len(self.holidays), 11)
self.assertIn(date(2014, 1, 3), self.holidays)
self.assertEqual(self.holidays.get(date(2014, 1, 3)), "Fake Holiday")
def read_holidays(db,tname,kw):
# holidays is a very small table. Super easy to just reacquire it in full on every update.
h_dc = (holidays.US(state='DC',\
years=range(cabi_start_datetime.year,5+datetime.datetime.now().year)))
df_holidays = pd.DataFrame.from_dict(h_dc,orient='index',columns=['hol_name'])\
.reset_index().rename(columns={'index':'date'})
return(df_holidays)
async def is_holiday(ctx):
"""Sends a picture of a turkey on Thanksgiving.
Can be extended to other holidays as well.
"""
logger.info("global check: checking holiday")
now = datetime.now(tz=timezone(-timedelta(hours=4))).date()
us = holidays.US()
if now in us:
if us.get(now) == "Thanksgiving":
await send_bird(
ctx,
"Wild Turkey",
"images",
Filter(),
message=
"**It's Thanksgiving!**\nGo celebrate with your family.",
)
raise GenericError(code=666)
if us.get(now) == "Independence Day":
await send_bird(
ctx,
"Bald Eagle",
"images",
Filter(),
message=
"**It's Independence Day!**\nEnjoy this birb responsibly.",
)
raise GenericError(code=666)
elif now == date(now.year, 4, 1):
return await drone_attack(ctx)
return True
def configure(self, config_name, action, contents):
"""
The main configuration callback.
"""
_log.info('Received configuration {} signal: {}'.format(
action, config_name))
self.current_config = self.default_config.copy()
self.current_config.update(contents)
self.analysis_name = self.current_config.get("analysis_name")
self.schedule_time = self.current_config.get("schedule_time")
self.device = self.current_config.get("device")
self.maximum_hour_threshold = self.current_config.get("mht")
self.excess_operation = self.current_config.get("excess_operation")
self.timezone = self.current_config.get("timezone", "PDT")
self.condition_list = self.current_config.get("condition_list", {})
self.device_true_time = 0
_log.info("current date time {}".format(datetime.utcnow()))
self.on_subscribe()
# self.core.periodic(self.interval, self.run_schedule)
self.device_true_time = 0 #at mid night zero the total minute
date_today = datetime.utcnow().astimezone(
dateutil.tz.gettz(self.timezone))
if date_today in holidays.US(
years=2020) or date_today.weekday() == 5 and 6:
schedule_time = "* * * * *"
else:
schedule_time = self.schedule_time
self.core.schedule(cron(schedule_time), self.run_schedule)
