class DateConverter(object):
def __init__(self, year, month, day, lunar):
self._year = year
self._month = month
self._day = day
self._lunar = lunar
self._intercalation = None
self._calendar = KoreanLunarCalendar()
@property
def year(self):
return self._year
@property
def month(self):
return self._month
@property
def day(self):
return self._day
@property
def intercalation(self):
return self._get_intercalation()
@property
def solar_day(self):
return self._get_solar_day()
@property
def lunar_day(self):
return self._get_lunar_day()
def _get_intercalation(self):
if self._lunar == True:
if self._date.year % 4 == 0 or self._date.year % 400 == 0:
self._intercalation = True
else:
self._intercalation = False
else:
self._intercalation = None
return self._intercalation
def _get_solar_day(self):
self._calendar.setLunarDate(self._year, self._month, self._day,
self._intercalation)
solar_date = self._calendar.SolarIsoFormat()
return solar_date
def _get_lunar_day(self):
self._calendar.setSolarDate(self._year, self._month, self._day)
lunar_date = self._calendar.LunarIsoFormat()
return lunar_date
def __del__(self):
del self._calendar
def to_solar_datetime(self, is_intercalation=None, strict=False):
dt = self.astimezone_kst(self)
if is_intercalation is None:
is_intercalation = self._is_intercalation
calendar = KoreanLunarCalendar()
valid = calendar.setLunarDate(dt.year, dt.month, dt.day,
is_intercalation)
if not valid:
if strict:
raise ValueError('Invalid lunar date (%s, %s, %s, %s)' %
(dt.year, dt.month, dt.day, is_intercalation))
else:
calendar.solarYear = dt.year
calendar.solarMonth = dt.month
calendar.solarDay = dt.day
dt = datetime.datetime(
calendar.solarYear,
calendar.solarMonth,
calendar.solarDay,
dt.hour,
dt.minute,
dt.second,
dt.microsecond,
tzinfo=self.kst,
)
return dt
def lunar_gapja(self, lunarDate):
intercalation = False
if '윤달' in lunarDate:
intercalation = True
lunarDate = lunarDate.replace(INTERCALATION, '')
calendar = KoreanLunarCalendar()
try:
lunar = dt_util.parse_date(lunarDate)
calendar.setLunarDate(lunar.year, lunar.month, lunar.day,
intercalation)
except AttributeError:
try:
calendar.setLunarDate(lunarDate[:4], lunarDate[5:7],
lunarDate[8:], intercalation)
except:
return "-"
return calendar.getGapJaString()
def korean_lunar_to_solar(year, month, day, is_intercalation=False):
calendar = KoreanLunarCalendar()
is_valid = calendar.setLunarDate(year, month, day, is_intercalation)
if not is_valid:
raise ValueError(
"Invalid date for lunar date: (year=%r, month=%r, day=%r, is_intercalation=%r)"
% (year, month, day, is_intercalation))
return (calendar.solarYear, calendar.solarMonth, calendar.solarDay)
def printInformation(year, is_intercalation=False):
today = datetime.today()
year = today.year
month = today.month
day = today.day
calendar = KoreanLunarCalendar()
calendar.setSolarDate(year, month, day)
print('Year: {}'.format(year))
# 할머니: (음) 5/23
calendar.setLunarDate(year, 5, 23, is_intercalation)
print('할머니 제사 (음) 5/23')
print('* Solar: {}'.format(calendar.SolarIsoFormat()))
print('* Lunar: {}'.format(calendar.LunarIsoFormat()))
print('* Hangul: {}'.format(calendar.getGapJaString()))
print('* Hanja: {}'.format(calendar.getChineseGapJaString()))
calendar.setLunarDate(year, 5, 1, is_intercalation)
print('초하루 (음) 5/1')
print('* Solar: {}'.format(calendar.SolarIsoFormat()))
print('* Lunar: {}'.format(calendar.LunarIsoFormat()))
print('* Hangul: {}'.format(calendar.getGapJaString()))
print('* Hanja: {}'.format(calendar.getChineseGapJaString()))
print('------------------------------')
# 할아버지: (음) 8/6
calendar.setLunarDate(year, 8, 6, is_intercalation)
print('할아버지 제사 (음) 8/6')
print('* Solar: {}'.format(calendar.SolarIsoFormat()))
print('* Lunar: {}'.format(calendar.LunarIsoFormat()))
print('* Hangul: {}'.format(calendar.getGapJaString()))
print('* Hanja: {}'.format(calendar.getChineseGapJaString()))
print('초하루 (음) 8/1')
calendar.setLunarDate(year, 8, 1, is_intercalation)
print('* Solar: {}'.format(calendar.SolarIsoFormat()))
print('* Lunar: {}'.format(calendar.LunarIsoFormat()))
print('* Hangul: {}'.format(calendar.getGapJaString()))
print('* Hanja: {}'.format(calendar.getChineseGapJaString()))
def lunar_to_solar(self, today, thisYear):
lunarDate = self._date
calendar = KoreanLunarCalendar()
if thisYear or self._mmdd:
calendar.setLunarDate(today.year, lunarDate.month, lunarDate.day,
self._intercalation)
if calendar.SolarIsoFormat() == '0000-00-00':
lunarDate2 = lunarDate - timedelta(1)
calendar.setLunarDate(today.year, lunarDate2.month,
lunarDate2.day, self._intercalation)
_LOGGER.warn("Non-existent date correction : %s -> %s",
lunarDate, calendar.SolarIsoFormat())
else:
calendar.setLunarDate(lunarDate.year, lunarDate.month,
lunarDate.day, self._intercalation)
return dt_util.parse_date(calendar.SolarIsoFormat())
def lunar_to_solar(self, lunarDate, intercal):
calendar = KoreanLunarCalendar()
calendar.setLunarDate(lunarDate.year, lunarDate.month, lunarDate.day,
intercal)
return dt_util.parse_date(calendar.SolarIsoFormat())
class Korea(HolidayBase):
# https://publicholidays.co.kr/ko/2020-dates/
# https://en.wikipedia.org/wiki/Public_holidays_in_South_Korea
# http://www.law.go.kr/%EB%B2%95%EB%A0%B9/%EA%B4%80%EA%B3%B5%EC%84%9C%EC%9D%98%20%EA%B3%B5%ED%9C%B4%EC%9D%BC%EC%97%90%20%EA%B4%80%ED%95%9C%20%EA%B7%9C%EC%A0%95
def __init__(self, **kwargs):
self.country = "KR"
self.korean_cal = KoreanLunarCalendar()
HolidayBase.__init__(self, **kwargs)
def _populate(self, year):
alt_holiday = "Alternative holiday of "
# New Year's Day
name = "New Year's Day"
first_date = date(year, JAN, 1)
if self.observed:
self[first_date] = name
if first_date.weekday() == SUN:
self[first_date + rd(days=+1)] = alt_holiday + \
self.first_lower(name)
first_date = first_date + rd(days=+1)
else:
self[first_date] = name
else:
self[first_date] = name
# Lunar New Year
name = "Lunar New Year's Day"
preceding_day_lunar = "The day preceding of " + name
second_day_lunar = "The second day of " + name
dt = self.get_solar_date(year, 1, 1)
new_year_date = date(dt.year, dt.month, dt.day)
if self.observed and year >= 2015:
if new_year_date.weekday() in [TUE, WED, THU, FRI]:
self[new_year_date + rd(days=-1)] = preceding_day_lunar
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_lunar
elif new_year_date.weekday() in [SAT, SUN, MON]:
self[new_year_date + rd(days=-1)] = preceding_day_lunar
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_lunar
self[new_year_date + rd(days=+2)] = alt_holiday + name
else:
self[new_year_date + rd(days=-1)] = preceding_day_lunar
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_lunar
# Independence Movement Day
name = "Independence Movement Day"
independence_date = date(year, MAR, 1)
self[independence_date] = name
# Tree Planting Day
name = "Tree Planting Day"
planting_date = date(year, APR, 5)
if self.observed and 1949 <= year <= 2007 and year != 1960:
self[planting_date] = name
else:
# removed from holiday since 2007
pass
# Birthday of the Buddha
name = "Birthday of the Buddha"
dt = self.get_solar_date(year, 4, 8)
buddha_date = date(dt.year, dt.month, dt.day)
self[buddha_date] = name
# Children's Day
name = "Children's Day"
childrens_date = date(year, MAY, 5)
if year >= 1975:
self[childrens_date] = name
if self.observed and year >= 2015:
if childrens_date.weekday() == SUN:
self[childrens_date + rd(days=+1)] = alt_holiday + name
if childrens_date.weekday() == SAT:
self[childrens_date + rd(days=+2)] = alt_holiday + name
# if holiday overlaps with other holidays, should be next day.
# most likely: Birthday of the Buddah
if self[childrens_date] != name:
self[childrens_date + rd(days=+1)] = alt_holiday + name
else:
# no children's day before 1975
pass
# Labour Day
name = "Labour Day"
labour_date = date(year, MAY, 1)
self[labour_date] = name
# Memorial Day
name = "Memorial Day"
memorial_date = date(year, JUN, 6)
self[memorial_date] = name
# Constitution Day
name = "Constitution Day"
constitution_date = date(year, JUL, 17)
if self.observed and 1948 <= year <= 2007:
self[constitution_date] = name
else:
# removed from holiday since 2008
pass
# Liberation Day
name = "Liberation Day"
libration_date = date(year, AUG, 15)
if self.observed and year >= 1945:
self[libration_date] = name
else:
pass
# Korean Mid Autumn Day
name = "Chuseok"
preceding_day_chuseok = "The day preceding of " + name
second_day_chuseok = "The second day of " + name
dt = self.get_solar_date(year, 8, 15)
new_year_date = date(dt.year, dt.month, dt.day)
if self.observed and year >= 2014:
if new_year_date.weekday() in [TUE, WED, THU, FRI]:
self[new_year_date + rd(days=-1)] = preceding_day_chuseok
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_chuseok
elif new_year_date.weekday() in [SAT, SUN, MON]:
self[new_year_date + rd(days=-1)] = preceding_day_chuseok
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_chuseok
self[new_year_date + rd(days=+2)] = alt_holiday + name
else:
self[new_year_date + rd(days=-1)] = preceding_day_chuseok
self[new_year_date] = name
self[new_year_date + rd(days=+1)] = second_day_chuseok
# National Foundation Day
name = "National Foundation Day"
foundation_date = date(year, OCT, 3)
self[foundation_date] = name
# Hangul Day
name = "Hangeul Day"
hangeul_date = date(year, OCT, 9)
self[hangeul_date] = name
# Christmas Day
name = "Christmas Day"
christmas_date = date(year, DEC, 25)
self[christmas_date] = name
# Just for year 2020 - since 2020.08.15 is Sat, the government
# decided to make 2020.08.17 holiday, yay
name = "Alternative public holiday"
alt_date = date(2020, OCT, 17)
self[alt_date] = name
# convert lunar calendar date to solar
def get_solar_date(self, year, month, day):
self.korean_cal.setLunarDate(year, month, day, False)
return date(self.korean_cal.solarYear, self.korean_cal.solarMonth,
self.korean_cal.solarDay)
def first_lower(self, s):
return s[0].lower() + s[1:]
class Vietnam(HolidayBase):
# https://publicholidays.vn/
# http://vbpl.vn/TW/Pages/vbpqen-toanvan.aspx?ItemID=11013 Article.115
# https://www.timeanddate.com/holidays/vietnam/
def __init__(self, **kwargs):
self.country = "VN"
self.korean_cal = KoreanLunarCalendar()
HolidayBase.__init__(self, **kwargs)
def _populate(self, year):
# New Year's Day
name = "International New Year's Day"
first_date = date(year, JAN, 1)
self[first_date] = name
if self.observed:
self[first_date] = name
if first_date.weekday() == SAT:
self[first_date + rd(days=+2)] = name + " observed"
elif first_date.weekday() == SUN:
self[first_date + rd(days=+1)] = name + " observed"
# Lunar New Year
name = [
"Vietnamese New Year", # index: 0
"The second day of Tet Holiday", # index: 1
"The third day of Tet Holiday", # index: 2
"The forth day of Tet Holiday", # index: 3
"The fifth day of Tet Holiday", # index: 4
"Vietnamese New Year's Eve", # index: -1
]
dt = self.get_solar_date(year, 1, 1)
new_year_date = date(dt.year, dt.month, dt.day)
if self.observed:
for i in range(-1, 5, 1):
tet_day = new_year_date + rd(days=+i)
self[tet_day] = name[i]
# Vietnamese Kings' Commemoration Day
# https://en.wikipedia.org/wiki/H%C3%B9ng_Kings%27_Festival
if year >= 2007:
name = "Hung Kings Commemoration Day"
dt = self.get_solar_date(year, 3, 10)
king_hung_date = date(dt.year, dt.month, dt.day)
self[king_hung_date] = name
else:
pass
# Liberation Day/Reunification Day
name = "Liberation Day/Reunification Day"
libration_date = date(year, APR, 30)
self[libration_date] = name
# International Labor Day
name = "International Labor Day"
labor_date = date(year, MAY, 1)
self[labor_date] = name
# Independence Day
name = "Independence Day"
independence_date = date(year, SEP, 2)
self[independence_date] = name
# convert lunar calendar date to solar
def get_solar_date(self, year, month, day):
self.korean_cal.setLunarDate(year, month, day, False)
return date(self.korean_cal.solarYear, self.korean_cal.solarMonth,
self.korean_cal.solarDay)
class CalendarCalculator:
def __init__(self):
self.lunarCalculator = KoreanLunarCalendar()
def isLunarMonth(self, year: int) -> bool:
'''
Judge lunar month
:param year: the year
:return: boolean type data
'''
if year % 4 == 0 and year % 100 != 0 or year % 400 == 0:
return True
#if ((i % 4 == 0 & & i % 100 != 0) | | i % 400 == 0)
#elif year % 400 == 0:
#return True
else:
return False
def toSolarDate(self, year: int, month: int, day: int):
'''
Convert from lunar date to solar date
:param year: lunar date of year
:param month: lunar date of month
:param day: lunar date of day
:return: lunar date with tuple which have 3 arguments
'''
self.lunarCalculator.setLunarDate(year, month, day,
self.isLunarMonth(year))
formatedDate = self.formatDate(self.lunarCalculator.SolarIsoFormat())
return formatedDate
def toLunarDate(self, year: int, month: int, day: int) -> tuple:
'''
Convert from solar date to lunar date
:param year: solar date of year
:param month: solar date of month
:param day: solar date of day
:return: solar date with tuple which have 3 arguments
'''
self.lunarCalculator.setSolarDate(year, month, day)
formatedDate = self.formatDate(self.lunarCalculator.LunarIsoFormat())
return formatedDate
def formatDate(self, date: str) -> tuple:
'''
Format string type to tuple
:param date: string type value date ex) '2018-12-9'
:return: tuple which have 3 arguments ex) (2018, 12, 9)
'''
return tuple(map(int, date.split('-')))
def getSolarHoliday(self, year: int, month: int, day: int,
holiday: str) -> tuple:
rawDate = self.toSolarDate(year, month, day)
rawDate = (rawDate[1], rawDate[2], holiday)
return rawDate
def getToLunarDate(self, year, month, day):
self.lunarCalculator.setSolarDate(year, month, day)
return self.lunarCalculator.LunarIsoFormat()