holidays 0.78__py3-none-any.whl → 0.79__py3-none-any.whl

holidays/calendars/__init__.py

@@ -26,3 +26,4 @@ from holidays.calendars.mongolian import _CustomMongolianHolidays, _MongolianLun
 from holidays.calendars.persian import _Persian
 from holidays.calendars.sinhala import _SinhalaLunar, _CustomSinhalaHolidays
 from holidays.calendars.thai import _ThaiLunisolar, KHMER_CALENDAR, THAI_CALENDAR
+from holidays.calendars.tibetan import _TibetanLunisolar, _CustomTibetanHolidays

holidays/calendars/chinese.py

@@ -1325,11 +1325,21 @@ class _ChineseLunisolar:
     def _get_holiday(self, holiday: str, year: int, calendar=None) -> tuple[Optional[date], bool]:
         calendar = calendar or self.__calendar
         self.__verify_calendar(calendar)
-        custom_calendar_dates = getattr(self, f"{calendar}_{holiday}_DATES", {})
+        confirmed_dates = getattr(
+            self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {}
+        )
+        confirmed_years = getattr(
+            self, f"{holiday}_DATES_CONFIRMED_YEARS_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", (0, 0)
+        )
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
-        exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
-        dt = exact_dates.get(year, custom_calendar_dates.get(year, estimated_dates.get(year, ())))
-        return date(year, *dt) if dt else None, year not in exact_dates
+        custom_calendar_dates = getattr(self, f"{calendar}_{holiday}_DATES", {})
+        dt = confirmed_dates.get(
+            year, custom_calendar_dates.get(year, estimated_dates.get(year, ()))
+        )
+        is_confirmed = year in confirmed_dates or (
+            confirmed_years[0] <= year <= confirmed_years[1]
+        )
+        return date(year, *dt) if dt else None, not is_confirmed
 
     def buddha_birthday_date(self, year: int, calendar=None) -> tuple[Optional[date], bool]:
         return self._get_holiday(BUDDHA_BIRTHDAY, year, calendar)

holidays/calendars/ethiopian.py

@@ -0,0 +1,31 @@
+#  holidays
+#  --------
+#  A fast, efficient Python library for generating country, province and state
+#  specific sets of holidays on the fly. It aims to make determining whether a
+#  specific date is a holiday as fast and flexible as possible.
+#
+#  Authors: Vacanza Team and individual contributors (see CONTRIBUTORS file)
+#           dr-prodigy <dr.prodigy.github@gmail.com> (c) 2017-2023
+#           ryanss <ryanssdev@icloud.com> (c) 2014-2017
+#  Website: https://github.com/vacanza/holidays
+#  License: MIT (see LICENSE file)
+
+ETHIOPIAN_CALENDAR = "ETHIOPIAN_CALENDAR"
+
+
+def is_ethiopian_leap_year(year: int) -> bool:
+    """Determine if the Ethiopian year that starts in the given Gregorian year is a leap year.
+
+    Ethiopian leap years follow the Coptic/Julian rule:
+        * Every 4 years without exception (no century rule).
+        * The Ethiopian year starts on September 11 (or 12 in an Ethiopian leap year).
+
+    Args:
+        year:
+            Gregorian year to evaluate.
+
+    Returns:
+        `True` if an Ethiopian leap year starts in the given Gregorian year, `False` otherwise.
+    """
+
+    return (year + 1) % 4 == 0

holidays/calendars/islamic.py

@@ -3971,11 +3971,23 @@ class _IslamicLunar:
     }
 
     def _get_holiday(self, holiday: str, year: int) -> Iterable[tuple[date, bool]]:
+        confirmed_dates = getattr(
+            self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {}
+        )
+        confirmed_years = getattr(
+            self, f"{holiday}_DATES_CONFIRMED_YEARS_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", ()
+        )
         estimated_dates = getattr(self, f"{holiday}_DATES", {})
-        exact_dates = getattr(self, f"{holiday}_DATES_{_CustomCalendar.CUSTOM_ATTR_POSTFIX}", {})
-        for year in (year - 1, year):
-            for dt in _normalize_tuple(exact_dates.get(year, estimated_dates.get(year, ()))):
-                yield date(year, *dt), year not in exact_dates
+
+        for check_year in (year - 1, year):
+            for dt in _normalize_tuple(
+                confirmed_dates.get(check_year, estimated_dates.get(check_year, ()))
+            ):
+                is_confirmed = check_year in confirmed_dates or any(
+                    year_from <= check_year <= year_to
+                    for year_from, year_to in _normalize_tuple(confirmed_years)
+                )
+                yield date(check_year, *dt), not is_confirmed
 
     def _is_long_ramadan(self, eid_al_fitr: date) -> bool:
         """Check whether the Ramadan preceding the given Eid al-Fitr date lasted 30 days.

holidays/calendars/julian.py

@@ -11,3 +11,17 @@
 #  License: MIT (see LICENSE file)
 
 JULIAN_CALENDAR = "JULIAN_CALENDAR"
+
+
+def julian_calendar_drift(year: int) -> int:
+    """Return the Julian–Gregorian date drift relative to the 1899–2099 baseline.
+
+    Args:
+        year:
+            Gregorian year to check.
+
+    Returns:
+        Number of days to add/subtract relative to the 1899–2099 baseline.
+    """
+
+    return -13 if year <= 1582 else (year // 100) - (year // 400) - 15

holidays/calendars/mandaean.py

@@ -0,0 +1,59 @@
+#  holidays
+#  --------
+#  A fast, efficient Python library for generating country, province and state
+#  specific sets of holidays on the fly. It aims to make determining whether a
+#  specific date is a holiday as fast and flexible as possible.
+#
+#  Authors: Vacanza Team and individual contributors (see CONTRIBUTORS file)
+#           dr-prodigy <dr.prodigy.github@gmail.com> (c) 2017-2023
+#           ryanss <ryanssdev@icloud.com> (c) 2014-2017
+#  Website: https://github.com/vacanza/holidays
+#  License: MIT (see LICENSE file)
+
+from datetime import date
+from typing import Optional
+
+from holidays.calendars.gregorian import _timedelta
+
+
+class _Mandaean:
+    """
+    Mandaean calendar for 1901-2100 years.
+    https://en.wikipedia.org/wiki/Mandaean_calendar
+    """
+
+    # Begin of 445271 Mandaean year.
+    START_DATE = date(1901, 8, 16)
+    START_YEAR = 1901
+    END_YEAR = 2100
+
+    def new_year_date(self, year: int) -> Optional[date]:
+        """
+        Return Gregorian date of Mandaean new year (1 Dowla) in a given Gregorian year.
+        """
+        if year < _Mandaean.START_YEAR or year > _Mandaean.END_YEAR:
+            return None
+
+        return _timedelta(_Mandaean.START_DATE, 365 * (year - _Mandaean.START_YEAR))
+
+    def mandaean_to_gregorian(self, year: int, month: int, day: int) -> Optional[date]:
+        """
+        Return Gregorian date of Mandaean day and month of the year that begins in a given
+        Gregorian year.
+        Extra 5 days inserted after 8th month are considered as 13th month.
+        """
+        start_date = self.new_year_date(year)
+        if not start_date:
+            return None
+
+        if not (1 <= month <= 13) or not (1 <= day <= 30) or (month == 13 and not (1 <= day <= 5)):
+            return None
+
+        if month < 9:
+            delta = 30 * (month - 1)
+        elif month == 13:
+            delta = 30 * 8
+        else:
+            delta = 30 * (month - 1) + 5
+
+        return _timedelta(start_date, delta + day - 1)