holidays 0.83__py3-none-any.whl → 0.84__py3-none-any.whl

holidays/calendars/balinese_saka.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.gregorian import MAR, APR
 
@@ -99,11 +98,11 @@ class _BalineseSakaLunar:
         2050: (MAR, 24),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> Optional[date]:
+    def _get_holiday(self, holiday: str, year: int) -> date | None:
         dt = getattr(self, f"{holiday}_DATES", {}).get(year, ())
         return date(year, *dt) if dt else None
 
-    def nyepi_date(self, year: int) -> Optional[date]:
+    def nyepi_date(self, year: int) -> date | None:
         """
         Data References:
             * [1983-2025](https://id.wikipedia.org/wiki/Indonesia_dalam_tahun_1983)

holidays/calendars/buddhist.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.custom import _CustomCalendar
 from holidays.calendars.gregorian import MAY, JUN
@@ -427,16 +426,16 @@ class _BuddhistLunisolar:
         2100: (MAY, 23),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> tuple[Optional[date], bool]:
+    def _get_holiday(self, holiday: str, year: int) -> tuple[date | None, bool]:
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
         exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
         dt = exact_dates.get(year, estimated_dates.get(year, ()))
         return date(year, *dt) if dt else None, year not in exact_dates
 
-    def vesak_date(self, year: int) -> tuple[Optional[date], bool]:
+    def vesak_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(VESAK, year)
 
-    def vesak_may_date(self, year: int) -> tuple[Optional[date], bool]:
+    def vesak_may_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(VESAK_MAY, year)
 
 

holidays/calendars/burmese.py

@@ -12,7 +12,6 @@
 
 from datetime import date
 from functools import cache
-from typing import Optional
 
 from holidays.calendars.gregorian import _timedelta
 
@@ -124,7 +123,7 @@ class _BurmeseLunisolar:
         return date(y, m, d)
 
     @cache
-    def _get_start_date(self, year: int) -> Optional[date]:
+    def _get_start_date(self, year: int) -> date | None:
         if year < self.START_YEAR or year > self.END_YEAR:
             return None
 
@@ -137,7 +136,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(self.START_DATE, delta_days)
 
-    def thingyan_dates(self, year: int) -> tuple[Optional[date], Optional[date]]:
+    def thingyan_dates(self, year: int) -> tuple[date | None, date | None]:
         """Calculate key dates of Thingyan (Myanmar New Year festival) - Akya day
             and Atat day.
 
@@ -157,7 +156,7 @@ class _BurmeseLunisolar:
 
         return self.jdn_to_gregorian(round(jk)), self.jdn_to_gregorian(round(ja))
 
-    def kason_full_moon_date(self, year: int) -> Optional[date]:
+    def kason_full_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of Full Moon Day of Kason.
 
         15th day of 2nd month (Kason).
@@ -180,7 +179,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(start_date, +43)
 
-    def waso_full_moon_date(self, year: int) -> Optional[date]:
+    def waso_full_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of Full Moon Day of Waso.
 
         15th day of 4th month (Waso).
@@ -203,7 +202,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(next_year_start_date, -252)
 
-    def thadingyut_full_moon_date(self, year: int) -> Optional[date]:
+    def thadingyut_full_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of Full Moon Day of Thadingyut.
 
         15th day of 7th month (Thadingyut).
@@ -226,7 +225,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(next_year_start_date, -163)
 
-    def tazaungmon_waxing_moon_date(self, year: int) -> Optional[date]:
+    def tazaungmon_waxing_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of 1st Waxing Day of Tazaungmon.
 
         1st day of 8th month (Tazaungmon).
@@ -249,7 +248,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(next_year_start_date, -148)
 
-    def tazaungmon_full_moon_date(self, year: int) -> Optional[date]:
+    def tazaungmon_full_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of Full Moon Day of Tazaungmon.
 
         15th day of 8th month (Tazaungmon).
@@ -272,7 +271,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(next_year_start_date, -134)
 
-    def pyatho_waxing_moon_date(self, year: int) -> Optional[date]:
+    def pyatho_waxing_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of 1st Waxing Day of Pyatho.
 
         1st day of 10th month (Pyatho).
@@ -295,7 +294,7 @@ class _BurmeseLunisolar:
 
         return _timedelta(next_year_start_date, -89)
 
-    def tabaung_full_moon_date(self, year: int) -> Optional[date]:
+    def tabaung_full_moon_date(self, year: int) -> date | None:
         """Calculate the Gregorian date of Full Moon Day of Tabaung.
 
         15th day of 12th month (Tabaung).

holidays/calendars/chinese.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.custom import _CustomCalendar
 from holidays.calendars.gregorian import JAN, FEB, MAR, APR, MAY, JUN, SEP, OCT, NOV, DEC
@@ -1340,7 +1339,7 @@ class _ChineseLunisolar:
                 f"Supported calendars: {', '.join(sorted(supported_calendars))}"
             )
 
-    def _get_holiday(self, holiday: str, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def _get_holiday(self, holiday: str, year: int, calendar=None) -> tuple[date | None, bool]:
         calendar = calendar or self.__calendar
         self.__verify_calendar(calendar)
         confirmed_dates = getattr(
@@ -1359,25 +1358,25 @@ class _ChineseLunisolar:
         )
         return date(year, *dt) if dt else None, not is_confirmed
 
-    def buddha_birthday_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def buddha_birthday_date(self, year: int, calendar=None) -> tuple[date | None, bool]:
         return self._get_holiday(BUDDHA_BIRTHDAY, year, calendar)
 
-    def double_ninth_date(self, year: int) -> tuple[Optional[date], bool]:
+    def double_ninth_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(DOUBLE_NINTH, year)
 
-    def dragon_boat_date(self, year: int) -> tuple[Optional[date], bool]:
+    def dragon_boat_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(DRAGON_BOAT, year)
 
-    def hung_kings_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def hung_kings_date(self, year: int, calendar=None) -> tuple[date | None, bool]:
         return self._get_holiday(HUNG_KINGS, year, calendar)
 
-    def lunar_new_year_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def lunar_new_year_date(self, year: int, calendar=None) -> tuple[date | None, bool]:
         return self._get_holiday(LUNAR_NEW_YEAR, year, calendar)
 
-    def mid_autumn_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def mid_autumn_date(self, year: int, calendar=None) -> tuple[date | None, bool]:
         return self._get_holiday(MID_AUTUMN, year, calendar)
 
-    def winter_solstice_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
+    def winter_solstice_date(self, year: int, calendar=None) -> tuple[date | None, bool]:
         """Return Winter Solstice (22nd solar term in Chinese Lunisolar calendar) date.
 
         !!! note "Note"

holidays/calendars/hebrew.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.gregorian import FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC
 
@@ -1598,36 +1597,36 @@ class _HebrewLunisolar:
         2100: (OCT, 13),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> Optional[date]:
+    def _get_holiday(self, holiday: str, year: int) -> date | None:
         dt = getattr(self, f"{holiday}_DATES", {}).get(year, ())
         return date(year, *dt) if dt else None
 
     def hanukkah_date(self, year: int) -> set[date]:
         return {dt for y in (year - 1, year) if (dt := self._get_holiday(HANUKKAH, y)) is not None}
 
-    def israel_independence_date(self, year: int) -> Optional[date]:
+    def israel_independence_date(self, year: int) -> date | None:
         return self._get_holiday(INDEPENDENCE_DAY, year)
 
-    def lag_baomer_date(self, year: int) -> Optional[date]:
+    def lag_baomer_date(self, year: int) -> date | None:
         return self._get_holiday(LAG_BAOMER, year)
 
-    def passover_date(self, year: int) -> Optional[date]:
+    def passover_date(self, year: int) -> date | None:
         return self._get_holiday(PASSOVER, year)
 
-    def purim_date(self, year: int) -> Optional[date]:
+    def purim_date(self, year: int) -> date | None:
         return self._get_holiday(PURIM, year)
 
-    def rosh_hashanah_date(self, year: int) -> Optional[date]:
+    def rosh_hashanah_date(self, year: int) -> date | None:
         return self._get_holiday(ROSH_HASHANAH, year)
 
-    def shavuot_date(self, year: int) -> Optional[date]:
+    def shavuot_date(self, year: int) -> date | None:
         return self._get_holiday(SHAVUOT, year)
 
-    def sukkot_date(self, year: int) -> Optional[date]:
+    def sukkot_date(self, year: int) -> date | None:
         return self._get_holiday(SUKKOT, year)
 
-    def tisha_bav_date(self, year: int) -> Optional[date]:
+    def tisha_bav_date(self, year: int) -> date | None:
         return self._get_holiday(TISHA_BAV, year)
 
-    def yom_kippur_date(self, year: int) -> Optional[date]:
+    def yom_kippur_date(self, year: int) -> date | None:
         return self._get_holiday(YOM_KIPPUR, year)

holidays/calendars/hindu.py

@@ -12,7 +12,6 @@
 
 from collections.abc import Iterable
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.custom import _CustomCalendar
 from holidays.calendars.gregorian import JAN, FEB, MAR, APR, MAY, AUG, SEP, OCT, NOV, DEC
@@ -1396,7 +1395,7 @@ class _HinduLunisolar:
         2035: (APR, 14),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> tuple[Optional[date], bool]:
+    def _get_holiday(self, holiday: str, year: int) -> tuple[date | None, bool]:
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
         exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
         dt = exact_dates.get(year, estimated_dates.get(year, ()))
@@ -1409,85 +1408,85 @@ class _HinduLunisolar:
             for dt in _normalize_tuple(exact_dates.get(year, estimated_dates.get(year, ()))):
                 yield date(year, *dt), year not in exact_dates
 
-    def buddha_purnima_date(self, year: int) -> tuple[Optional[date], bool]:
+    def buddha_purnima_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(BUDDHA_PURNIMA, year)
 
-    def chhath_puja_date(self, year: int) -> tuple[Optional[date], bool]:
+    def chhath_puja_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(CHHATH_PUJA, year)
 
-    def diwali_date(self, year: int) -> tuple[Optional[date], bool]:
+    def diwali_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(DIWALI, year)
 
-    def diwali_india_date(self, year: int) -> tuple[Optional[date], bool]:
+    def diwali_india_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(DIWALI_INDIA, year)
 
-    def dussehra_date(self, year: int) -> tuple[Optional[date], bool]:
+    def dussehra_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(DUSSEHRA, year)
 
-    def ganesh_chaturthi_date(self, year: int) -> tuple[Optional[date], bool]:
+    def ganesh_chaturthi_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GANESH_CHATURTHI, year)
 
-    def govardhan_puja_date(self, year: int) -> tuple[Optional[date], bool]:
+    def govardhan_puja_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GOVARDHAN_PUJA, year)
 
-    def gudi_padwa_date(self, year: int) -> tuple[Optional[date], bool]:
+    def gudi_padwa_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GUDI_PADWA, year)
 
     def guru_gobind_singh_jayanti_date(self, year: int) -> Iterable[tuple[date, bool]]:
         return self._get_holiday_set(GURU_GOBIND_SINGH_JAYANTI, year)
 
-    def guru_nanak_jayanti_date(self, year: int) -> tuple[Optional[date], bool]:
+    def guru_nanak_jayanti_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GURU_NANAK_JAYANTI, year)
 
-    def gyalpo_losar_date(self, year: int) -> tuple[Optional[date], bool]:
+    def gyalpo_losar_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GYALPO_LOSAR, year)
 
-    def holi_date(self, year: int) -> tuple[Optional[date], bool]:
+    def holi_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(HOLI, year)
 
-    def pongal_date(self, year: int) -> tuple[Optional[date], bool]:
+    def pongal_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(PONGAL, year)
 
-    def janmashtami_date(self, year: int) -> tuple[Optional[date], bool]:
+    def janmashtami_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(JANMASHTAMI, year)
 
-    def maha_ashtami_date(self, year: int) -> tuple[Optional[date], bool]:
+    def maha_ashtami_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MAHA_ASHTAMI, year)
 
-    def maha_navami_date(self, year: int) -> tuple[Optional[date], bool]:
+    def maha_navami_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MAHA_NAVAMI, year)
 
-    def maha_shivaratri_date(self, year: int) -> tuple[Optional[date], bool]:
+    def maha_shivaratri_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MAHA_SHIVARATRI, year)
 
-    def mahavir_jayanti_date(self, year: int) -> tuple[Optional[date], bool]:
+    def mahavir_jayanti_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MAHAVIR_JAYANTI, year)
 
-    def makar_sankranti_date(self, year: int) -> tuple[Optional[date], bool]:
+    def makar_sankranti_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MAKAR_SANKRANTI, year)
 
-    def onam_date(self, year: int) -> tuple[Optional[date], bool]:
+    def onam_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(ONAM, year)
 
-    def raksha_bandhan_date(self, year: int) -> tuple[Optional[date], bool]:
+    def raksha_bandhan_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(RAKSHA_BANDHAN, year)
 
-    def ram_navami_date(self, year: int) -> tuple[Optional[date], bool]:
+    def ram_navami_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(RAM_NAVAMI, year)
 
-    def sharad_navratri_date(self, year: int) -> tuple[Optional[date], bool]:
+    def sharad_navratri_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(SHARAD_NAVRATRI, year)
 
-    def sonam_losar_date(self, year: int) -> tuple[Optional[date], bool]:
+    def sonam_losar_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(SONAM_LOSAR, year)
 
-    def tamu_losar_date(self, year: int) -> tuple[Optional[date], bool]:
+    def tamu_losar_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(TAMU_LOSAR, year)
 
-    def thaipusam_date(self, year: int) -> tuple[Optional[date], bool]:
+    def thaipusam_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(THAIPUSAM, year)
 
-    def vaisakhi_date(self, year: int) -> tuple[Optional[date], bool]:
+    def vaisakhi_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(VAISAKHI, year)
 
 

holidays/calendars/mandaean.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.gregorian import _timedelta
 
@@ -27,7 +26,7 @@ class _Mandaean:
     START_YEAR = 1901
     END_YEAR = 2100
 
-    def new_year_date(self, year: int) -> Optional[date]:
+    def new_year_date(self, year: int) -> date | None:
         """
         Return Gregorian date of Mandaean new year (1 Dowla) in a given Gregorian year.
         """
@@ -36,7 +35,7 @@ class _Mandaean:
 
         return _timedelta(_Mandaean.START_DATE, 365 * (year - _Mandaean.START_YEAR))
 
-    def mandaean_to_gregorian(self, year: int, month: int, day: int) -> Optional[date]:
+    def mandaean_to_gregorian(self, year: int, month: int, day: int) -> date | None:
         """
         Return Gregorian date of Mandaean day and month of the year that begins in a given
         Gregorian year.

holidays/calendars/mongolian.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.custom import _CustomCalendar
 from holidays.calendars.gregorian import JAN, FEB, MAR, MAY, JUN, OCT, NOV, DEC
@@ -322,19 +321,19 @@ class _MongolianLunisolar:
         2100: (FEB, 10),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> tuple[Optional[date], bool]:
+    def _get_holiday(self, holiday: str, year: int) -> tuple[date | None, bool]:
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
         exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
         dt = exact_dates.get(year, estimated_dates.get(year, ()))
         return date(year, *dt) if dt else None, year not in exact_dates
 
-    def buddha_day_date(self, year: int) -> tuple[Optional[date], bool]:
+    def buddha_day_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(BUDDHA_DAY, year)
 
-    def genghis_khan_day_date(self, year: int) -> tuple[Optional[date], bool]:
+    def genghis_khan_day_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(GENGHIS_KHAN_DAY, year)
 
-    def tsagaan_sar_date(self, year: int) -> tuple[Optional[date], bool]:
+    def tsagaan_sar_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(TSAGAAN_SAR, year)
 
 

holidays/calendars/persian.py

@@ -11,7 +11,6 @@
 #  License: MIT (see LICENSE file)
 
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.gregorian import _timedelta
 
@@ -32,7 +31,7 @@ class _Persian:
         """
         return (year % 33) in {3, 7, 11, 16, 20, 24, 28, 32}
 
-    def new_year_date(self, year: int) -> Optional[date]:
+    def new_year_date(self, year: int) -> date | None:
         """
         Return Gregorian date of Persian new year (1 Farvardin) in a given Gregorian year.
         """
@@ -51,7 +50,7 @@ class _Persian:
             day = 22
         return date(year, 3, day)
 
-    def persian_to_gregorian(self, year: int, j_month: int, j_day: int) -> Optional[date]:
+    def persian_to_gregorian(self, year: int, j_month: int, j_day: int) -> date | None:
         """
         Return Gregorian date of Persian day and month in a given Gregorian year.
         """

holidays/calendars/sinhala.py

@@ -12,7 +12,6 @@
 
 from collections.abc import Iterable
 from datetime import date
-from typing import Optional
 
 from holidays.calendars.custom import _CustomCalendar
 from holidays.calendars.gregorian import JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV, DEC
@@ -47,7 +46,7 @@ class _SinhalaLunar:
     """
 
     START_YEAR = 2003
-    END_YEAR = 2025
+    END_YEAR = 2026
 
     BAK_POYA_DATES = {
         2003: (APR, 16),
@@ -73,6 +72,7 @@ class _SinhalaLunar:
         2023: (APR, 5),
         2024: (APR, 23),
         2025: (APR, 12),
+        2026: (APR, 1),
     }
 
     BINARA_POYA_DATES = {
@@ -99,6 +99,7 @@ class _SinhalaLunar:
         2023: (SEP, 29),
         2024: (SEP, 17),
         2025: (SEP, 7),
+        2026: (SEP, 26),
     }
 
     DURUTHU_POYA_DATES = {
@@ -124,6 +125,7 @@ class _SinhalaLunar:
         2023: (JAN, 6),
         2024: (JAN, 25),
         2025: (JAN, 13),
+        2026: (JAN, 3),
     }
 
     ESALA_POYA_DATES = {
@@ -150,6 +152,7 @@ class _SinhalaLunar:
         2023: (AUG, 1),
         2024: (JUL, 20),
         2025: (JUL, 10),
+        2026: (JUL, 29),
     }
 
     IL_POYA_DATES = {
@@ -176,6 +179,7 @@ class _SinhalaLunar:
         2023: (NOV, 26),
         2024: (NOV, 15),
         2025: (NOV, 5),
+        2026: (NOV, 24),
     }
 
     MEDIN_POYA_DATES = {
@@ -202,6 +206,7 @@ class _SinhalaLunar:
         2023: (MAR, 6),
         2024: (MAR, 24),
         2025: (MAR, 13),
+        2026: (MAR, 2),
     }
 
     NAWAM_POYA_DATES = {
@@ -228,6 +233,7 @@ class _SinhalaLunar:
         2023: (FEB, 5),
         2024: (FEB, 23),
         2025: (FEB, 12),
+        2026: (FEB, 1),
     }
 
     NIKINI_POYA_DATES = {
@@ -254,6 +260,7 @@ class _SinhalaLunar:
         2023: (AUG, 30),
         2024: (AUG, 19),
         2025: (AUG, 8),
+        2026: (AUG, 27),
     }
 
     POSON_POYA_DATES = {
@@ -280,6 +287,7 @@ class _SinhalaLunar:
         2023: (JUN, 3),
         2024: (JUN, 21),
         2025: (JUN, 10),
+        2026: (JUN, 29),
     }
 
     UNDUVAP_POYA_DATES = {
@@ -306,6 +314,7 @@ class _SinhalaLunar:
         2023: (DEC, 26),
         2024: (DEC, 14),
         2025: (DEC, 4),
+        2026: (DEC, 23),
     }
 
     VAP_POYA_DATES = {
@@ -332,6 +341,7 @@ class _SinhalaLunar:
         2023: (OCT, 28),
         2024: (OCT, 17),
         2025: (OCT, 6),
+        2026: (OCT, 25),
     }
 
     VESAK_POYA_DATES = {
@@ -358,9 +368,10 @@ class _SinhalaLunar:
         2023: (MAY, 5),
         2024: (MAY, 23),
         2025: (MAY, 12),
+        2026: (MAY, 1),
     }
 
-    def _get_holiday(self, holiday: str, year: int) -> tuple[Optional[date], bool]:
+    def _get_holiday(self, holiday: str, year: int) -> tuple[date | None, bool]:
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
         exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
         dt = exact_dates.get(year, estimated_dates.get(year, ()))
@@ -373,40 +384,40 @@ class _SinhalaLunar:
             for dt in _normalize_tuple(exact_dates.get(year, estimated_dates.get(year, ()))):
                 yield date(year, *dt), year not in exact_dates
 
-    def bak_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def bak_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(BAK_POYA, year)
 
-    def binara_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def binara_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(BINARA_POYA, year)
 
     def duruthu_poya_date(self, year: int) -> Iterable[tuple[date, bool]]:
         return self._get_holiday_set(DURUTHU_POYA, year)
 
-    def esala_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def esala_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(ESALA_POYA, year)
 
-    def il_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def il_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(IL_POYA, year)
 
-    def medin_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def medin_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(MEDIN_POYA, year)
 
-    def nawam_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def nawam_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(NAWAM_POYA, year)
 
-    def nikini_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def nikini_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(NIKINI_POYA, year)
 
-    def poson_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def poson_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(POSON_POYA, year)
 
-    def unduvap_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def unduvap_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(UNDUVAP_POYA, year)
 
-    def vap_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def vap_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(VAP_POYA, year)
 
-    def vesak_poya_date(self, year: int) -> tuple[Optional[date], bool]:
+    def vesak_poya_date(self, year: int) -> tuple[date | None, bool]:
         return self._get_holiday(VESAK_POYA, year)