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()
def makeCalendar(yearInput, monthInput):
global dateFrame
global c
for child in dateFrame.winfo_children():
child.destroy()
print(yearInput, monthInput)
title["text"] = "{}년 {}월".format(yearInput, monthInput)
c = calendar.month(yearInput, monthInput)
lunar_c = KoreanLunarCalendar()
# lunar.setSolarDate(2017, 6, 24)
#print(lunar.LunarIsoFormat())
dateIndex = c.find('Su')
c = c[dateIndex + 2:]
index = 0
for i in range(6):
for j in range(7):
day = c[index:index + 3]
day = day.replace('\n', '')
if day.strip() != '': #day가 비어있지 않으면 음력 추가
lunar_day = day.strip()
lunar_day = int(lunar_day)
lunar_c.setSolarDate(yearInput, monthInput, lunar_day)
lunar_day = lunar_c.LunarIsoFormat()
lunar_index = lunar_day.find('-')
lunar_day = lunar_day[lunar_index + 1:]
lunar_day = lunar_day.replace('-', '.')
day = day + '\n' + lunar_day
name = Button(dateFrame, text=day)
name.grid(row=i, column=j)
if index + 3 <= len(c): index += 3
if index >= len(c): break
return c
def make_calendar(self): #달력 만드는 함수
try:
for dates in self.m_cal:
for date in dates:
if date == 0:
continue
self.delete_buttons(date)
self.delete_buttons
except AttributeError:
pass
year = int(self.year_str_var.get()) #년도 저장
month = self.month_names.index(self.month_str_var.get()) #월 저장
self.m_cal = calendar.monthcalendar(year, month)
for dates in self.m_cal:
row = self.m_cal.index(dates) + 1
for date in dates:
col = dates.index(date)
if date == 0:
continue
k_calendar = KoreanLunarCalendar() #음력으로 바꿔주는 코드
k_calendar.setSolarDate(year, month, date)
k_day = k_calendar.LunarIsoFormat()
num = 0
for a in self.dat2_list:
m = int(a[1])
d = int(a[2])
if m == month and d == int(date):
num = num + 1
self.make_button(str(date), str(row), str(col),
str(k_day.split('-')[1]),
str(k_day.split('-')[2]),
num) #날짜, 행, 열을 인자로 함수를 넣어줌.
def korean_solar_to_lunar(year, month, day):
calendar = KoreanLunarCalendar()
is_valid = calendar.setSolarDate(year, month, day)
if not is_valid:
raise ValueError(
"Invalid date for solar date: (year=%r, month=%r, day=%r)" %
(year, month, day))
return (calendar.lunarYear, calendar.lunarMonth, calendar.lunarDay)
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 from_solar_datetime(cls, dt):
dt = cls.astimezone_kst(dt)
calendar = KoreanLunarCalendar()
valid = calendar.setSolarDate(dt.year, dt.month, dt.day)
if not valid:
raise ValueError('Invalid solar date')
dt = cls(
calendar.lunarYear,
calendar.lunarMonth,
calendar.lunarDay,
dt.hour,
dt.minute,
dt.second,
dt.microsecond,
tzinfo=cls.kst,
is_intercalation=calendar.isIntercalation,
)
return dt
def _update_internal_state(self, time_date):
date = dt_util.as_local(time_date).date()
calendar = KoreanLunarCalendar()
calendar.setSolarDate(date.year, date.month, date.day)
lunar_date = calendar.LunarIsoFormat()
self._state = lunar_date
self._attribute = {
'korean_gapja': calendar.getGapJaString(),
'chinese_gapja': calendar.getChineseGapJaString()
}
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
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 check_holiday(date):
is_holiday = False
year = date[0:4]
month = date[5:7]
day = date[8:]
month_day = month + day
date = datetime.datetime(int(year), int(month), int(day), 1, 0,
0) # str -> datetime으로 변환
lunar_calendar = KoreanLunarCalendar()
lunar_calendar.setSolarDate(int(year), int(month), int(day))
lunar_month_day = lunar_calendar.LunarIsoFormat()
lunar_month_day = lunar_month_day[5:7] + lunar_month_day[8:]
if month_day in WORKING['holidays'] or lunar_month_day in WORKING[
'lunarHolidays']:
is_holiday = True
elif date.weekday() == 5 or date.weekday() == 6:
is_holiday = True
elif date.weekday() == 0:
# 대체공휴일 적용
yesterday = date - timedelta(days=1)
yesterday = datetimeToDate(yesterday)
two_days_ago = date - timedelta(days=2)
two_days_ago = datetimeToDate(two_days_ago)
if yesterday in WORKING[
'alternativeVacation'] or two_days_ago in WORKING[
'alternativeVacation']:
is_holiday = True
if USE_LUNAR_NEW_YEAR:
if not is_holiday and int(month) < 4:
# 음력 1월 1일 전날의 날짜를 특정하기 어려워서 아래의 logic을 사용
# 12월 29일수도 있고 12월 30일일 수도 있음 윤달이 있으면 단순히 처리하기 쉽지 않음
tomorrow = date + timedelta(days=1)
tomorrow = datetimeToDate(tomorrow)
lunar_calendar.setSolarDate(int(year), int(tomorrow[0:2]),
int(tomorrow[2:4]))
lunar_month_day = lunar_calendar.LunarIsoFormat()
lunar_month_day = lunar_month_day[5:7] + lunar_month_day[8:]
if lunar_month_day == '0101':
is_holiday = True
return is_holiday
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 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())
from korean_lunar_calendar import KoreanLunarCalendar
calendar = KoreanLunarCalendar()
def luna_day(solor_year, solor_month, solor_day):
# params : year(년), month(월), day(일)
calendar.setSolarDate(solor_year, solor_month, solor_day)
return calendar.lunarDay
def luna_month(solor_year, solor_month, solor_day):
calendar.setSolarDate(solor_year, solor_month, solor_day)
return calendar.lunarMonth
def luna_year(solor_year, solor_month, solor_day):
calendar.setSolarDate(solor_year, solor_month, solor_day)
return calendar.lunarYear
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())
def solar_to_lunar(self, solarDate):
calendar = KoreanLunarCalendar()
calendar.setSolarDate(solarDate.year, solarDate.month, solarDate.day)
lunar = calendar.LunarIsoFormat()
lunar = lunar.replace(' Intercalation', INTERCALATION)
return lunar
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()
def setup(self, year, month):
rangeLength = calendar.monthrange(
year, month) # 월의 끝날 구하기.tuple 자료형식"<class 'tuple'>"
# frame을 2개로 나누어서 관리 위에는 사진 아래는 날짜
frame1 = tk.Frame(calendarWindow)
frame1.grid(row=0)
frame2 = tk.Frame(calendarWindow)
frame2.grid(row=1)
# frame1에 이미지 넣기
photo = PhotoImage(file="D:\\teddy.gif")
w = Label(frame1, image=photo)
w.grid(row=0)
prevM = Button(frame2,
text="이전달",
fg="blue",
font="Times 10 bold",
command=self.prevF,
width=5).grid(row=0, column=1) #이전달 버튼
tk.Label(frame2, text=(year), fg="red",
font="Times 12 bold").grid(row=0, column=0) #연 표시
tk.Label(frame2, text=(month), fg="red",
font="Times 15 bold").grid(row=0, column=3) #월 표시
nextM = Button(frame2,
text="다음달",
fg="blue",
font="Times 10 bold",
command=self.nexF,
width=5).grid(row=0, column=5) #다음달 버튼
showCsv = Button(frame2,
text="SHOW",
fg="orange",
font="Times 10 bold",
command=self.csvf,
width=5).grid(row=0, column=6) # csv파일 보여주는 버튼
list = []
i = 0
for val1, weekbutton in enumerate(self.weekDay): #요일그리기
tk.Button(frame2, text=self.weekDay[val1], fg='green',
width=5).grid(row=2, column=i)
i += 1
count = 1
rows = 2
columns = 0
sum = rangeLength[1] + rangeLength[0] + 1
# print(sum)
if (sum == 38):
sum = 31
ccc = rangeLength[0]
v = tk.IntVar()
lunarCalendar = KoreanLunarCalendar()
def dateButtonF():
self.f = open('D:\\birthdayfile.CSV', 'r')
self.lines = csv.reader(self.f)
print("버튼함수, 버튼에 해당하는 날짜는 " + str(v.get()))
lunarCalendar.setSolarDate(self.year, self.month, v.get())
print("음력날짜는: " + lunarCalendar.LunarIsoFormat())
i = 0
birlist = []
for line in self.lines:
if i > 2 and i < 30:
if (int(line[3]) % 100 == int(v.get()) and
(int(line[3]) % 10000 - int(line[3]) % 100) / 100
== self.month):
birlist.append(str(line[1]))
i += 1
tk.messagebox.showinfo(
"음력날짜", ('클릭한 날짜의 음력\n', lunarCalendar.LunarIsoFormat(),
'\n생일인 사람 수와 이름\n', birlist, len(birlist), '명'))
# 날짜그리기
for startDate in range(sum):
if (startDate % 7 == 0):
rows = rows + 1
if (startDate <= ccc and ccc != 6):
tk.Button(frame2, text=" ", width=5,
height=2).grid(row=rows, column=columns)
else:
tk.Radiobutton(frame2,
text=count,
command=dateButtonF,
indicatoron=0,
variable=v,
value=count,
width=5,
height=2).grid(row=rows, column=columns)
count = count + 1
columns += 1
if (columns == 7):
columns = 0
namecard = tk.Label(frame1,
text=self.setname,
fg="red",
font="Times 7 bold").grid(row=1)
seasoncard = tk.Label(frame1,
text=self.season.get(month),
fg='pink',
font="Time 15 bold").grid(row=2)
calendarWindow.mainloop()
self.f.close()
def __init__(self):
self.lunarCalculator = KoreanLunarCalendar()
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 __init__(self, **kwargs):
self.country = "KR"
self.korean_cal = KoreanLunarCalendar()
HolidayBase.__init__(self, **kwargs)
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)
