def easterDatCalc(self, year):
good_friday_date = easter(year) - timedelta(
2
) # easter(year) gives the easter sunday date - 2 days = good Friday
easter_monday_date = easter(year) + timedelta(
1) # easter(year) + 1 day = Easter Monday
print("good_friday_date: ", good_friday_date)
print("easter_monday_date: ", easter_monday_date)
def first_bcp(self, feast, year, full_year, by_date):
"""First free weekday after Pentecost for which there's no other commemoration"""
current_day = easter(year) + datetime.timedelta(weeks=7)
while current_day.year == year:
# only weekdays
if utils.weekday(current_day) == 'sun':
current_day = current_day + datetime.timedelta(days=1)
continue
# only if the feast is valid for this day
ok = valid_in_list([feast], current_day)
if ok is None:
current_day = current_day + datetime.timedelta(days=1)
continue
# only if another feast is not scheduled for that day
cdate = utils.day_to_lookup(current_day)
if len(full_year[cdate].feasts) == 0:
if cdate not in by_date:
by_date[cdate] = {
'day': copy.deepcopy(current_day),
'feasts': []
}
by_date[cdate]['feasts'].append(feast)
break
current_day = current_day + datetime.timedelta(days=1)
return by_date
def is_holiday(date_i):
year = date_i.year
holidays = [
date(year, 1, 1), #NEW YEAR'S DAY
### HOWEVER, sometimes New Year's Day falls on a weekend and is then observed on Monday. If it falls on a Saturday (a normal non-free parking day), what happens?
### Actually 2017-1-1 was a Sunday, and other days around that appeared to have normal non-holiday activity.
### So if New Year's Day falls on a Sunday, it is observed (at least as a parking holiday) on Sunday.
### Current data shows no evidence of any of these dates shifting when they fall on Saturdays or Sundays.
### A few dates still need more verification.
nth_m_day(
year, 1, 3,
0), #MARTIN LUTHER KING JR'S BIRTHDAY (third Monday of January)
easter(year) - timedelta(days=2), #GOOD FRIDAY
last_m_day(year, 5, 0), #MEMORIAL DAY (last Monday in May)
date(year, 7, 4), #INDEPENDENCE DAY (4TH OF JULY)
# [ ] This could be observed on a different day when
# the 4th falls on a Sunday.
nth_m_day(year, 9, 1, 0), #LABOR DAY (first Monday in September)
date(
year, 11, 11
), #VETERANS' DAY (seems to be observed on Saturdays when if falls on Saturdays)
# [ ] This could be observed on a different day (check when this is observed if it falls on a Sunday).
nth_m_day(year, 11, 4, 3), #THANKSGIVING DAY
nth_m_day(year, 11, 4, 4), #DAY AFTER THANKSGIVING
date(
year, 12, 25
), #CHRISTMAS DAY # There's no evidence that Christmas or the day after Christmas are
date(year, 12, 26)
] #DAY AFTER CHRISTMAS # observed on days other than the 25th and 26th.
return date_i in holidays
def is_holiday(date_i):
year = date_i.year
holidays = [
date(year, 1, 1), #NEW YEAR'S DAY
### HOWEVER, sometimes New Year's Day falls on a weekend and is then observed on Monday. If it falls on a Saturday (a normal non-free parking day), what happens?
# Really an observed_on() function is needed to offset
# some holidays correctly.
nth_m_day(
year, 1, 3,
0), #MARTIN LUTHER KING JR'S BIRTHDAY (third Monday of January)
easter(year) - timedelta(days=2), #GOOD FRIDAY
last_m_day(year, 5, 0), #MEMORIAL DAY (last Monday in May)
date(year, 7, 4), #INDEPENDENCE DAY (4TH OF JULY)
# [ ] This could be observed on a different day.
nth_m_day(year, 9, 1, 0), #LABOR DAY
# [ ] This could be observed on a different day.
date(year, 11, 11), #VETERANS' DAY
# [ ] This could be observed on a different day.
nth_m_day(year, 11, 4, 3), #THANKSGIVING DAY
#nth_m_day(year,11,4,4),#DAY AFTER THANKSGIVING # Most city departments do not observe this one.
date(year, 12, 25), #CHRISTMAS DAY
# [ ] This could be observed on a different day.
#date(year,12,26) # Most city departments do not observe this one.
] #DAY AFTER CHRISTMAS
# [ ] This could be observed on a different day.
return date_i in holidays
def MardiGrasDate():
"""
A function to return the date of Mardi Gras in the current year.
:return: a date formatted as per the python datetime module, representing Mardi Gras of the current year
"""
thiseaster = easter(date.today().year)
MardiGras = thiseaster - datetime.timedelta(days=47)
return MardiGras
def MardiGrasDate():
"""
A function to return the date of Mardi Gras in the current year.
:return: a date formatted as per the python datetime module, representing Mardi Gras of the current year
"""
thiseaster = easter(date.today().year)
MardiGras = thiseaster - datetime.timedelta(days=47)
return MardiGras
def get_holiday_values(year):
holidays = {'year': year}
easterDate = easter(year)
holidays['easter'] = Holiday(easterDate)
holidays['ascension'] = Holiday(easterDate, 39)
holidays['pentecost'] = Holiday(easterDate, 49)
holidays['trinity'] = Holiday(easterDate, 56)
holidays['corpus'] = Holiday(easterDate, 60)
return holidays
def ejemplo_dateutil():
now = parse("Sat Oct 11 17:13:46 UTC 2003")
today = now.date()
year = rrule(YEARLY,dtstart=now,bymonth=8,bymonthday=13,byweekday=FR)[0].year
rdelta = relativedelta(easter(year), today)
print(f"Today is: {today}")
print(f"Year with next Aug 13th on a Friday is: {year}")
print(f"How far is the Easter of that year: {rdelta}")
print(f"And the Easter of that year is: {today + rdelta}")
def get_holiday_values(year):
holidays = {"year": year}
easterDate = easter(year)
holidays["easter"] = Holiday(easterDate)
holidays["ascension"] = Holiday(easterDate, 39)
holidays["pentecost"] = Holiday(easterDate, 49)
holidays["trinity"] = Holiday(easterDate, 56)
holidays["corpus"] = Holiday(easterDate, 60)
return holidays
def get_red_days_for_year(year):
# first: generate list of red day objects with dates and names for the year
# then iterate over them, and check whether they already exist for that year
# if they don't already exist, save them as new Event objects of the "Off day" type.
red_days = []
red_day = {
"date": "1980-01-01",
"name": "Unnamed holiday",
}
# fixed red days
red_days.append({"date": str(year)+"-01-01", "name": "New Year's Day"})
red_days.append({"date": str(year)+"-12-25", "name": "First day of Christmas"})
red_days.append({"date": str(year)+"-12-26", "name": "Second day of Christmas"})
red_days.append({"date": str(year)+"-05-01", "name": "International Workers' Day"})
red_days.append({"date": str(year)+"-05-17", "name": "Constitution Day"})
# non-fixed red days, these are a bit more involved
easter_day = easter(year)
red_days.append({"date": easter_day.strftime('%Y-%m-%d'), "name": "First day of Easter"})
second_easter_day = easter(year) + timedelta(days=1)
red_days.append({"date": second_easter_day.strftime('%Y-%m-%d'), "name": "Second day of Easter"})
ascension_of_jesus_day = easter_day + timedelta(days=39)
red_days.append({"date": ascension_of_jesus_day.strftime('%Y-%m-%d'), "name": "Ascension of Jesus Day"})
first_day_of_pentecost = easter_day + timedelta(days=49)
red_days.append({"date": first_day_of_pentecost.strftime('%Y-%m-%d'), "name": "First day of Pentecost"})
second_day_of_pentecost = easter_day + timedelta(days=50)
red_days.append({"date": second_day_of_pentecost.strftime('%Y-%m-%d'), "name": "Second day of Pentecost"})
long_friday = easter_day - timedelta(days=2)
red_days.append({"date": long_friday.strftime('%Y-%m-%d'), "name": "Long Friday"})
sheer_thursday = easter_day - timedelta(days=3)
red_days.append({"date": sheer_thursday.strftime('%Y-%m-%d'), "name": "Sheer Thursday"})
return(red_days)
def weeksbeforeEaster(dataset):
#calculates the weeks before easter for every year thanks to easter library.
_weeksbefore = []
for i in range(0, dataset.shape[0]):
dateTokens = dataset[i, 0].split('-')
onedate = date(int(dateTokens[0]), int(dateTokens[1]),
int(dateTokens[2]))
_easter = easter(int(dateTokens[0]), 3)
_subdays = _easter - onedate
_subdays = round(_subdays.days / 7.0, 0)
_weeksbefore.append(_subdays)
return _weeksbefore
def create_events(year):
# initialise events
global event
event = {}
end = r"}\\[-5mm] \normalsize{"
for month in range(1, 13):
for day in range(1, 32):
event[(day, month)] = end
event[(1, 1)] += "New Year's Day" + end
event[(2, 1)] += "Day After New Year's Day" + end
event[(6, 2)] += "Waitangi Day" + end
event[(mothers_day(year).day,
mothers_day(year).month)] += "UK Mother's Day" + end
event[(easter(year).day - 2, easter(year).month)] += "Good Friday" + end
event[(easter(year).day, easter(year).month)] += "Easter Sunday" + end
event[(easter(year).day + 1, easter(year).month)] += "Easter Monday" + end
event[(25, 4)] += "ANZAC Day" + end
event[(nth_day(1, 1, year, 6), 6)] += "Queen's Birthday" + end
event[(nth_day(3, 7, year, 6), 6)] += "UK Father's Day" + end
event[(24, 6)] += "Matariki" + end # Change this date manually every year
event[(nth_day(4, 1, year, 10), 10)] += "Labour Day" + end
event[(nth_day(2, 5, year, 11,
2), 11)] += "Canterbury" + end + "Anniversary Day" + end
event[(25, 12)] += "Christmas Day" + end
event[(26, 12)] += "Boxing Day" + end
def calc_holidays(year: int = date.today().year) -> List:
""" calculates dates for holidays in the given year
Parameters
----------
year : int
the year to calculate to holidays for, defaults to current year
Returns
-------
holidates
a list containing the holidays with dates
TODO: Add option to get holidays for other states than Hessen
"""
# dates for static holidays
holidates = [{
'Name': 'Neujahr',
'Datum': date(year, 1, 1)
}, {
'Name': '1ter Mai',
'Datum': date(year, 5, 1)
}, {
'Name': 'Tag der dt. Einheit',
'Datum': date(year, 10, 3)
}, {
'Name': '1ter Weihnachtstag',
'Datum': date(year, 12, 25)
}, {
'Name': '2ter Weihnachtstag',
'Datum': date(year, 12, 26)
}]
# timedeltas for easter dependent holidays
deltas = {
'Karfreitag': timedelta(days=-2),
'Ostermontag': timedelta(days=1),
'Himmelfahrt': timedelta(days=39),
'Pfingstmontag': timedelta(days=50),
'Fronleichnam': timedelta(days=60) # only in BW,BY,HE,NW,RP,SL
}
for k, v in deltas.items():
holiday = {'Name': k, 'Datum': easter(year) + v}
holidates.append(holiday)
# sort output by date
holidates = sorted(holidates, key=lambda dates: dates['Datum'])
return holidates
def Annunciation(year):
annunciation = date(year, 3, 25)
easter_ = easter(year)
# the second monday after easter if 25 is during holy week or Pascal week
if (easter_ <= date(year, 4, 2)):
d = timedelta(weeks=1, days=1)
return easter_ + d
# the following monday if 25/03 is a sunday
if (annunciation.weekday() == 6):
d = timedelta(days=1)
return annunciation + d
return annunciation
def Annunciation(year):
""
annonciation = date(year, 3, 25)
easter_ = easter(year)
# the second monday after easter if 25 is during holy week or Pascal week
if(easter_<=date(year,4,2)):
d = timedelta(weeks=1, days=1)
return easter_+d
# the following monday if 25/03 is a sunday
if(annonciation.weekday()==6):
d = timedelta(days=1)
return annonciation+d
return annonciation
def manipulate_yield_data(df_treasury):
# Take out 2 month yield and only use 24 months of data
df_treasury = df_treasury.drop(['2 MO'], axis=1).last('24M')
df_treasury.reset_index(inplace=True)
# Get the data for the last day of each business quarter for the
# last 24 months.
df_us_treasury = df_treasury.loc[df_treasury.Date.isin(
df_treasury.Date + BQuarterEnd())]
# Once every 5 or 6 years the end of the first business
# quarter is Good Friday. The financial markets in the US
# are closed on Good Friday. When this occurs we have to get
# data from the day before Good Friday.
# Create a list of the years that are in the df_treasury dataframe
df_dates = pd.to_datetime(df_treasury['Date']).dt.year.unique()
for date in df_dates:
# Calculate Good Friday. It's two days before Easter Sunday
goodfriday = easter(date) + timedelta(days=-2)
# Calculate the end of the business quarter for the quarter that
# Good Friday is in.
Bqtr_end_date = (pd.to_datetime(goodfriday) +
BQuarterEnd(0)).date()
# check to see if Good Friday is the last day of the business quarter
if goodfriday == Bqtr_end_date:
# Subtract one day from Good Friday to get financial end of qtr
end_of_qtr = pd.to_datetime(goodfriday + timedelta(days=-1))
# Get the row in df_treasury with the information that we need
df_temp = df_treasury[df_treasury.Date == end_of_qtr]
# Add the dataframe with the one record that we need to the
# dataframe with the business quarter end data
df_us_treasury = pd.concat([df_us_treasury, df_temp])
# Add data from most recent date in df_treasury to df_us_treasury
df_us_treasury = df_us_treasury.append(df_treasury.iloc[-1])
# Update the index so that the data prints out correctly
df_us_treasury = df_us_treasury.sort_values(by=['Date'],
ascending=False)
df_treasury = df_treasury.sort_values(by=['Date'], ascending=False)
df_us_treasury['Date'] = pd.to_datetime(df_us_treasury['Date'],
format='%Y-%m-%d').dt.date
return df_us_treasury, df_treasury
def manipulate_yield_data(df_treasury):
# Take out 2 month yield and only use last two years data
df_treasury = df_treasury.drop(['2 MO'], axis=1).last('2Y')
df_treasury.reset_index(inplace=True)
# Get data from last day of each business quarter
# Add data from the most recent day we have
# Transpose the dataframe
df_us_treasury = df_treasury.loc[df_treasury.Date.isin(
df_treasury.Date + BQuarterEnd())]
# Once every 5 or 6 years the end of the first business
# quarter is Good Friday. The financial markets in the US
# are closed on Good Friday. When this occurs we have to get
# data from the day before Good Friday.
# Create a list of the years that are in the df_treasury dataframe
df_dates = pd.to_datetime(df_treasury['Date']).dt.year.unique()
for date in df_dates:
# Calculate Good Friday. It's two days before Easter Sunday
goodfriday = easter(date) + timedelta(days=-2)
# Calculate the end of the business quarter for the quarter that
# Good Friday is in.
Bqtr_end_date = (pd.to_datetime(goodfriday) +
BQuarterEnd(0)).date()
# check to see if Good Friday is the last day of the business quarter
if goodfriday == Bqtr_end_date:
# Subtract one day from Good Friday to get financial end of qtr
end_of_qtr = pd.to_datetime(goodfriday + timedelta(days=-1))
# Get the row in df_treasury with the information that we need
df_temp = df_treasury[df_treasury.Date == end_of_qtr]
# Add the dataframe with the one record that we need to the
# dataframe with the business quarter end data
df_us_treasury = pd.concat([df_us_treasury, df_temp])
df_us_treasury = (df_us_treasury.append(df_treasury.iloc[-1],
ignore_index=True)).T
return df_us_treasury, len(
df_us_treasury.index), len(df_us_treasury.columns) + 1
def holiday(self, monthDays):
easterDays = list()
if self.month in self.publicHolidays.keys():
days = self.publicHolidays.__getitem__(self.month)
for day in days:
newDate = str(self.year) + str(self._strMonth) + day
newDay = self.isHolidayOnSunday(newDate)
if newDay in monthDays: monthDays.remove(newDay)
# remove easter
easterSunday = easter(self.year)
# go back two days
_2daysLess = datetime.timedelta(days=-2)
goodFriday = easterSunday + _2daysLess
easterMonday = easterSunday + self._1daymore
easterDays.append(
datetime.datetime.strptime(str(goodFriday),
'%Y-%m-%d').strftime('%Y%m%d'))
easterDays.append(
datetime.datetime.strptime(str(easterMonday),
'%Y-%m-%d').strftime('%Y%m%d'))
for easterDay in easterDays:
if easterDay in monthDays: monthDays.remove(easterDay)
return monthDays
def Easter(year):
"Easter of given year. / Paques pour l'année [year]"
# Redefined to provide a consistent API
return easter(year)
#! /usr/bin/python
# -*- coding: utf-8 -*-
from dateutil.relativedelta import *
from dateutil.easter import *
from dateutil.rrule import *
from dateutil.parser import *
from datetime import *
today = date.today()
year = rrule(YEARLY, bymonth=8, bymonthday=16, byweekday=FR)[0].year
rdelta = relativedelta(easter(year), today)
fechacreada = date(2014, 06, 1)
now = date.today()
relaitive = str(relativedelta(
now,
fechacreada,
))
pasado_manyana = str(fechacreada)
def weeks_between(start, end):
weeks = rrule(WEEKLY, dtstart=start, until=end)
return weeks.count()
print "Hoy es:", today
print "El próximo año en que el 13 de agosto es viernes es el :", year
print "Faltan %s días para el Día de Pascua." % (rdelta)
def Easter(year):
"Easter of given year. / Paques pour l'année [year]"
# Redefined to provide a consistent API
return easter(year)
def Pentecost(year):
"Whit Sunday of given year. / Pentecote"
d=timedelta(weeks=7)
return easter(year)+d
def PalmSunday(year):
"Palm Sunday for given year. / Dimanche des Rameaux de l'année year"
d=timedelta(weeks=-1)
return easter(year)+d
def GoodFriday(year):
""
d=timedelta(days=-2)
return easter(year)+d
def AshWednesday(year):
"Ash Wednesday for given year. / Mercredi des Cendres de l'année $year"
d=timedelta(days=-46)
return easter(year)+d
def IsLentTime(date):
"Returns TRUE if provided date is during Lent. NOTE: this includes Sundays for now."
#TODO? : check if not sunday ?
return (date >= AshWednesday(date.year) and date < easter(date.year))
def CorpusChristi(year):
""
# Saint-Sacrement (Fete-Dieu)
d=timedelta(days=63)
return easter(year)+d
def PalmSunday(year):
"Palm Sunday for given year. / Dimanche des Rameaux de l'année year"
d=timedelta(weeks=-1)
return easter(year)+d
def Trinity(year):
""
d=timedelta(days=56)
return easter(year)+d
def Pentecost(year):
"Whit Sunday of given year. / Pentecote"
d=timedelta(weeks=7)
return easter(year)+d
def Ascension(year):
""
d=timedelta(days=39)
return easter(year)+d
def GoodFriday(year):
""
d=timedelta(days=-2)
return easter(year)+d
def IsLentTime(date):
"Returns TRUE if provided date is during Lent. NOTE: this includes Sundays for now."
#TODO? : check if not sunday ?
return (date >= AshWednesday(date.year) and date < easter(date.year))
def IsTriduum(date):
""
return (date >= HolyThursday(date.year) and date < easter(date.year))
def IsTriduum(date):
""
return (date >= HolyThursday(date.year) and date < easter(date.year))
def AshWednesday(year):
"Ash Wednesday for given year. / Mercredi des Cendres de l'année $year"
d=timedelta(days=-46)
return easter(year)+d
def IsInEasterOctave(date):
""
d=timedelta(weeks=1)
return (date >= easter(date.year) and date <= easter(year)+d)
def HolyThursday(year):
""
d=timedelta(days=-3)
return easter(year)+d
def IsHolyWeek(date):
""
return (date > PalmSunday(date.year) and date < easter(date.year))
def EasterVigil(year):
""
d=timedelta(days=-1)
return easter(year)+d
def CorpusChristi(year):
""
# Saint-Sacrement (Fete-Dieu)
d=timedelta(days=63)
return easter(year)+d
def Ascension(year):
""
d=timedelta(days=39)
return easter(year)+d
#
# In[7]:
import numpy as np
from math import radians, cos, sin, asin, sqrt
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import LabelEncoder
from sklearn import tree
import codecs
from sklearn.preprocessing import OneHotEncoder
from sklearn.linear_model import LogisticRegression
from datetime import date
from dateutil.easter import *
'''
easter(date,type)
type:
EASTER_JULIAN = 1
EASTER_ORTHODOX = 2
EASTER_WESTERN = 3
'''
"""*********************************"""
def monthsbeforeEaster(dataset):
#calculates the weeks before easter for every year thanks to easter library.
_weeksbefore = []
for i in range(0, dataset.shape[0]):
dateTokens = dataset[i, 0].split('-')
onedate = date(int(dateTokens[0]), int(dateTokens[1]),
def Trinity(year):
""
d=timedelta(days=56)
return easter(year)+d
def EasterVigil(year):
""
d=timedelta(days=-1)
return easter(year)+d
def IsEasterTide(date):
"Returns TRUE if provided date is during Pascal Time."
return (date >= easter(date.year) and date <= Pentecost(date.year))
int(weekWcal),
int(weekday))
print "%s-S%sW%s-%s" % (date[0],date[1],date[2],date[3])
return(date)
datetoWeekcal((2016,3,17))
#easter date to week calendar
easterweek = np.zeros(b, dtype=int)
for i in range(b):
easterweek[i] = datetoWeekcal(easter(2000+i))[2]
if easterweek[i]==13: easterweek[i]=0
fig = plt.figure(figsize=(50,2), dpi=480)
ax = fig.add_subplot(111)
majorLocator = MultipleLocator(10)
majorFormatter = FormatStrFormatter('%03d')
minorLocator = MultipleLocator(1)
ax.xaxis.set_major_locator(majorLocator)
ax.xaxis.set_major_formatter(majorFormatter)
ax.xaxis.set_minor_locator(minorLocator)
ax.plot(easterweek, ',', c='black')
ax.axes.set_ylim([-0.5,5.4])
plt.show()
def pasquetta(year):
return easter(int(year)) + datetime.timedelta(1)
def IsInEasterOctave(date):
""
d=timedelta(weeks=1)
return (date >= easter(date.year) and date <= easter(year)+d)
from dateutil.relativedelta import *
from dateutil.easter import *
from dateutil.rrule import *
from dateutil.parser import *
from datetime import *
import commands
import os
now = parse(commands.getoutput("date"))
today = now.date()
year = rrule(YEARLY,bymonth=8,bymonthday=13,byweekday=FR)[0].year
rdelta = relativedelta(easter(year), today)
print "Today is:", today
print "Year with next Aug 13th on a Friday is:", year
print "How far is the Easter of that year:", rdelta
print "And the Easter of that year is:", today+rdelta
def HolyThursday(year):
""
d=timedelta(days=-3)
return easter(year)+d
