pandas-market-calendars 4.4.0__py3-none-any.whl → 4.6.0__py3-none-any.whl

pandas_market_calendars/calendars/cme.py

@@ -31,6 +31,7 @@ from pandas_market_calendars.holidays.us import (
     ChristmasEveBefore1993,
     ChristmasEveInOrAfter1993,
     USBlackFridayInOrAfter1993,
+    USJuneteenthAfter2022,
     USIndependenceDay,
     USMartinLutherKingJrAfter1998,
     USMemorialDay,
@@ -98,6 +99,7 @@ class CMEEquityExchangeCalendar(MarketCalendar):
                         USPresidentsDay,
                         USMemorialDay,
                         USLaborDay,
+                        USJuneteenthAfter2022,
                         USIndependenceDay,
                         USThanksgivingDay,
                         USBlackFridayInOrAfter1993,
@@ -158,6 +160,7 @@ class CMEAgricultureExchangeCalendar(MarketCalendar):
                 USPresidentsDay,
                 GoodFriday,
                 USMemorialDay,
+                USJuneteenthAfter2022,
                 USIndependenceDay,
                 USLaborDay,
                 USThanksgivingDay,

pandas_market_calendars/calendars/cme_globex_agriculture.py

@@ -124,3 +124,49 @@ class CMEGlobexLivestockExchangeCalendar(CMEGlobexAgricultureExchangeCalendar):
                 ),
             )
         ]
+
+
+class CMEGlobexGrainsAndOilseedsExchangeCalendar(CMEGlobexAgricultureExchangeCalendar):
+    """
+    Exchange calendar for CME for Grains & Oilseeds
+
+    https://www.cmegroup.com/trading/agricultural/grain-and-oilseed.html
+
+    GLOBEX Trading Times
+    https://www.cmegroup.com/markets/agriculture/oilseeds/soybean.contractSpecs.html
+    https://www.cmegroup.com/markets/agriculture/grains/corn.contractSpecs.html
+    https://www.cmegroup.com/markets/agriculture/grains/wheat.contractSpecs.html
+    Sunday - Friday: 7:00 p.m. - 7:45 a.m. CT and Monday - Friday: 8:30 a.m. - 1:20 p.m. CT
+    """
+
+    aliases = [
+        "CMEGlobex_Grains",
+        "CMEGlobex_Oilseeds",
+    ]
+
+    regular_market_times = {
+        "market_open": ((None, time(19), -1),),  # offset by -1 day
+        "market_close": ((None, time(13, 20)),),
+        "break_start": ((None, time(7, 45)),),
+        "break_end": ((None, time(8, 30)),),
+    }
+
+    @property
+    def name(self):
+        return "CMEGlobex_GrainsAndOilseeds"
+
+    @property
+    def regular_holidays(self):
+        return AbstractHolidayCalendar(
+            rules=[
+                USNewYearsDay,
+                USMartinLutherKingJrAfter1998,
+                USPresidentsDay,
+                GoodFriday,
+                USMemorialDay,
+                USIndependenceDay,
+                USLaborDay,
+                USThanksgivingDay,
+                Christmas,
+            ]
+        )

pandas_market_calendars/calendars/eurex.py

@@ -43,13 +43,6 @@ MayBank = Holiday(
     day=1,
     days_of_week=(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY),
 )
-# German National Holiday (Tag der Deutschen Einheit)
-GermanNationalDay = Holiday(
-    "Tag der Deutschen Einheit",
-    month=10,
-    day=3,
-    days_of_week=(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY),
-)
 # Christmas Eve
 ChristmasEve = Holiday(
     "Christmas Eve",
@@ -116,7 +109,6 @@ class EUREXExchangeCalendar(MarketCalendar):
                 GoodFriday,
                 EasterMonday,
                 MayBank,
-                GermanNationalDay,
                 Christmas,
                 WeekendChristmas,
                 BoxingDay,

pandas_market_calendars/calendars/hkex.py

@@ -354,6 +354,9 @@ HKClosedDay = [
     Timestamp("2016-10-21", tz="UTC"),  # 台风海马1622
     # Timestamp(2017-06-12', tz='UTC'),  # 台风苗柏1702,期货夜盘17:35休市
     Timestamp("2017-08-23", tz="UTC"),  # 台风天鸽1713
+    Timestamp("2023-07-17", tz="UTC"),  # Typhoon closure
+    Timestamp("2023-09-01", tz="UTC"),  # Typhoon closure
+    Timestamp("2023-09-08", tz="UTC"),  # Typhoon closure
 ]
 
 

pandas_market_calendars/calendars/iex.py

@@ -1,9 +1,13 @@
 from datetime import time
 from itertools import chain
 
+from pandas import Timestamp, DatetimeIndex, Timedelta
 from pandas.tseries.holiday import AbstractHolidayCalendar
 from pytz import timezone
 
+from typing import Literal, Union
+from pandas_market_calendars import calendar_utils as u
+
 from pandas_market_calendars.holidays.nyse import (
     USPresidentsDay,
     GoodFriday,
@@ -106,7 +110,42 @@ class IEXExchangeCalendar(NYSEExchangeCalendar):
         return []
 
     def valid_days(self, start_date, end_date, tz="UTC"):
-        trading_days = super().valid_days(
-            start_date, end_date, tz=tz
-        )  # all NYSE valid days
-        return trading_days[~(trading_days <= "2013-08-25")]
+        start_date = Timestamp(start_date)
+        if start_date.tz is not None:
+            # Ensure valid Comparison to "2013-08-25" is possible
+            start_date.tz_convert(self.tz).tz_localize(None)
+
+        # Limit Start_date to the Exchange's Open
+        start_date = max(start_date, Timestamp("2013-08-25"))
+        return super().valid_days(start_date, end_date, tz=tz)
+
+    def date_range_htf(
+        self,
+        frequency: Union[str, Timedelta, int, float],
+        start: Union[str, Timestamp, int, float, None] = None,
+        end: Union[str, Timestamp, int, float, None] = None,
+        periods: Union[int, None] = None,
+        closed: Union[Literal["left", "right"], None] = "right",
+        *,
+        day_anchor: u.Day_Anchor = "SUN",
+        month_anchor: u.Month_Anchor = "JAN",
+    ) -> DatetimeIndex:
+
+        start, end, periods = u._error_check_htf_range(start, end, periods)
+
+        # Cap Beginning and end dates to the opening date of IEX
+        if start is not None:
+            start = max(start, Timestamp("2013-08-25"))
+        if end is not None:
+            end = max(end, Timestamp("2013-08-25"))
+
+        return u.date_range_htf(
+            self.holidays(),
+            frequency,
+            start,
+            end,
+            periods,
+            closed,
+            day_anchor=day_anchor,
+            month_anchor=month_anchor,
+        )

pandas_market_calendars/calendars/jpx.py

@@ -21,13 +21,17 @@ class JPXExchangeCalendar(MarketCalendar):
 
     Open Time: 9:31 AM, Asia/Tokyo
     LUNCH BREAK :facepalm: : 11:30 AM - 12:30 PM Asia/Tokyo
-    Close Time: 4:00 PM, Asia/Tokyo
+    Close Time: 3:30 PM, Asia/Tokyo
+
+    Market close of Japan changed from 3:00 PM to 3:30 PM on November 5, 2024
+    Reference:
+    https://www.jpx.co.jp/english/equities/trading/domestic/tvdivq0000006blj-att/tradinghours_eg.pdf
     """
 
     aliases = ["JPX", "XJPX"]
     regular_market_times = {
         "market_open": ((None, time(9)),),
-        "market_close": ((None, time(15)),),
+        "market_close": ((None, time(15)), ("2024-11-05", time(15, 30))),
         "break_start": ((None, time(11, 30)),),
         "break_end": ((None, time(12, 30)),),
     }

pandas_market_calendars/calendars/mirror.py

@@ -8,6 +8,8 @@ import exchange_calendars
 
 from pandas_market_calendars.market_calendar import MarketCalendar
 
+DAYMASKS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+
 
 class TradingCalendar(MarketCalendar):
     """
@@ -97,6 +99,23 @@ class TradingCalendar(MarketCalendar):
     def special_closes_adhoc(self):
         return self._ec.special_closes_adhoc
 
+    @property
+    def weekmask(self):
+        if hasattr(self._ec, "weekmask"):
+            if "1" in self._ec.weekmask or "0" in self._ec.weekmask:
+                # Convert 1s & 0s to Day Abbreviations
+                return " ".join(
+                    [
+                        DAYMASKS[i]
+                        for i, val in enumerate(self._ec.weekmask)
+                        if val == "1"
+                    ]
+                )
+            else:
+                return self._ec.weekmask
+        else:
+            return "Mon Tue Wed Thu Fri"
+
 
 calendars = exchange_calendars.calendar_utils._default_calendar_factories  # noqa
 

pandas_market_calendars/calendars/nyse.py

@@ -18,8 +18,12 @@ from itertools import chain
 
 import pandas as pd
 from pandas.tseries.holiday import AbstractHolidayCalendar
+from pandas.tseries.offsets import CustomBusinessDay
 from pytz import timezone
 
+from typing import Literal, Union
+from pandas_market_calendars import calendar_utils as u
+
 from pandas_market_calendars.holidays.nyse import (
     # Always Celebrated Holidays
     USNewYearsDayNYSEpost1952,
@@ -297,6 +301,8 @@ from pandas_market_calendars.holidays.nyse import (
     HurricaneSandyClosings2012,
     # 2018
     GeorgeHWBushDeath2018,
+    # 2025
+    JimmyCarterDeath2025,
 )
 from pandas_market_calendars.market_calendar import MarketCalendar
 
@@ -828,7 +834,28 @@ class NYSEExchangeCalendar(MarketCalendar):
 
     @property
     def weekmask(self):
-        return "Mon Tue Wed Thu Fri Sat"  # Market open on Saturdays thru 5/24/1952
+        return "Mon Tue Wed Thu Fri"
+
+    @property
+    def weekmask_pre_1952(self):
+        return "Mon Tue Wed Thu Fri Sat"
+
+    def holidays_pre_1952(self):
+        """
+        NYSE Market open on Saturdays pre 5/24/1952.
+        CustomBusinessDay object that can be used inplace of holidays() for dates prior to crossover
+
+        :return: CustomBusinessDay object of holidays
+        """
+        if hasattr(self, "_holidays_hist"):
+            return self._holidays_hist
+
+        self._holidays_hist = CustomBusinessDay(
+            holidays=self.adhoc_holidays,
+            calendar=self.regular_holidays,
+            weekmask=self.weekmask_pre_1952,
+        )
+        return self._holidays_hist
 
     @property
     def regular_holidays(self):
@@ -961,10 +988,10 @@ class NYSEExchangeCalendar(MarketCalendar):
                 September11Closings2001,
                 HurricaneSandyClosings2012,
                 GeorgeHWBushDeath2018,
+                JimmyCarterDeath2025,
             )
         )
 
-    #
     @property
     def special_closes(self):
         return [
@@ -1085,7 +1112,6 @@ class NYSEExchangeCalendar(MarketCalendar):
             ),
         ]
 
-    #
     @property
     def special_closes_adhoc(self):
         def _union_many(indexes):
@@ -1140,7 +1166,6 @@ class NYSEExchangeCalendar(MarketCalendar):
             ),
         ]
 
-    #
     @property
     def special_opens(self):
         return [
@@ -1254,7 +1279,6 @@ class NYSEExchangeCalendar(MarketCalendar):
             ),
         ]
 
-    #
     @property
     def special_opens_adhoc(self):
         return [
@@ -1272,7 +1296,7 @@ class NYSEExchangeCalendar(MarketCalendar):
             ),
         ]
 
-    # Override market_calendar.py
+    # Override market_calendar.py to split calc between pre & post 1952 Saturday Close
     def valid_days(self, start_date, end_date, tz="UTC"):
         """
         Get a DatetimeIndex of valid open business days.
@@ -1282,7 +1306,8 @@ class NYSEExchangeCalendar(MarketCalendar):
         :param tz: time zone in either string or pytz.timezone
         :return: DatetimeIndex of valid business days
         """
-        trading_days = super().valid_days(start_date, end_date, tz=tz)
+        start_date = pd.Timestamp(start_date, tz=tz)
+        end_date = pd.Timestamp(end_date, tz=tz)
 
         # Starting Monday Sept. 29, 1952, no more saturday trading days
         if tz is None:
@@ -1290,12 +1315,32 @@ class NYSEExchangeCalendar(MarketCalendar):
         else:
             saturday_end = self._saturday_end
 
-        above_cut_off = trading_days >= saturday_end
-        if above_cut_off.any():
-            above_and_saturday = (trading_days.weekday == 5) & above_cut_off
-            trading_days = trading_days[~above_and_saturday]
+        # Don't care about Saturdays. Call super.
+        if start_date > saturday_end:
+            return super().valid_days(start_date, end_date, tz=tz)
 
-        return trading_days
+        # Full Date Range is pre 1952. Augment the Super call
+        if end_date <= saturday_end:
+            return pd.date_range(
+                start_date,
+                end_date,
+                freq=self.holidays_pre_1952(),
+                normalize=True,
+                tz=tz,
+            )
+
+        # Range is split across 1952. Concatenate Two different Date_Range calls
+        days_pre = pd.date_range(
+            start_date,
+            saturday_end,
+            freq=self.holidays_pre_1952(),
+            normalize=True,
+            tz=tz,
+        )
+        days_post = pd.date_range(
+            saturday_end, end_date, freq=self.holidays(), normalize=True, tz=tz
+        )
+        return days_pre.union(days_post)
 
     def days_at_time(self, days, market_time, day_offset=0):
         days = super().days_at_time(days, market_time, day_offset=day_offset)
@@ -1309,6 +1354,103 @@ class NYSEExchangeCalendar(MarketCalendar):
             days = days.dt.tz_convert("UTC")
         return days
 
+    def date_range_htf(
+        self,
+        frequency: Union[str, pd.Timedelta, int, float],
+        start: Union[str, pd.Timestamp, int, float, None] = None,
+        end: Union[str, pd.Timestamp, int, float, None] = None,
+        periods: Union[int, None] = None,
+        closed: Union[Literal["left", "right"], None] = "right",
+        *,
+        day_anchor: u.Day_Anchor = "SUN",
+        month_anchor: u.Month_Anchor = "JAN",
+    ) -> pd.DatetimeIndex:
+        # __doc__ = MarketCalendar.date_range_htf.__doc__
+
+        start, end, periods = u._error_check_htf_range(start, end, periods)
+
+        args = {
+            "frequency": frequency,
+            "start": start,
+            "end": end,
+            "periods": periods,
+            "closed": closed,
+            "day_anchor": day_anchor,
+            "month_anchor": month_anchor,
+        }
+
+        saturday_end = self._saturday_end.tz_localize(None)
+
+        # All Dates post 1952 This is the most common use case so return it first
+        if start is not None and start > saturday_end:
+            return u.date_range_htf(self.holidays(), **args)
+
+        # ---- Start-Date to End-Date w/ pre-1952 ----
+        if start is not None and end is not None:
+            if end <= saturday_end:
+                # All pre 1952 Dates
+                return u.date_range_htf(self.holidays_pre_1952(), **args)
+            else:
+                # Split Range Across 1952
+                pre = u.date_range_htf(  # Only Generate to the last saturday
+                    self.holidays_pre_1952(), **(args | {"end": saturday_end})
+                )
+                post = u.date_range_htf(  # start generating from the last date of 'pre'
+                    self.holidays(), **(args | {"start": pre[-1]})
+                )
+                return pd.DatetimeIndex(pre.union(post), dtype="datetime64[ns]")
+
+        # ---- Periods from Start-Date w/ pre-1952 ----
+        elif start is not None and periods is not None:
+            # Start prior to 1952 & Number of periods given
+            rtn_dt = u.date_range_htf(self.holidays_pre_1952(), **args)
+            if rtn_dt[-1] <= saturday_end:
+                return rtn_dt  # never passed 1952, good to return
+
+            # Date Range Split.
+            pre = rtn_dt[rtn_dt <= saturday_end]
+            post = u.date_range_htf(
+                self.holidays(),
+                **(args | {"start": pre[-1], "periods": periods - len(pre) + 1}),
+            )
+            return pd.DatetimeIndex(pre.union(post)[:periods], dtype="datetime64[ns]")
+
+        # ---- Periods from End-Date ----
+        elif end is not None and periods is not None:
+            if end <= saturday_end:
+                # All Dates pre-1952, Good to return the normal call
+                return u.date_range_htf(self.holidays_pre_1952(), **args)
+            else:
+                rtn_dt = u.date_range_htf(self.holidays(), **args)
+
+                if rtn_dt[0] > saturday_end:
+                    return rtn_dt  # never passed 1952, good to return
+
+                # Date Range Split
+                post = rtn_dt[rtn_dt > saturday_end]
+                _, period_code = u._standardize_htf_freq(frequency)
+                altered_args = {
+                    # This nonsense is to realign the schedules as best as possible. This
+                    # essentially creates the 'pre-1952' equivalent date to the last generated 'post-1952'
+                    # date. Start the Range from there, then pre[0:-1] trims off that extra date where we
+                    # started from
+                    "end": post[0].to_period(period_code).end_time.normalize(),
+                    "periods": periods - len(post) + 2,
+                }
+                pre = u.date_range_htf(
+                    self.holidays_pre_1952(),
+                    **(args | altered_args),
+                )
+
+                return pd.DatetimeIndex(
+                    pre[:-1].union(post)[-periods:], dtype="datetime64[ns]"
+                )
+        else:
+            _, _ = u._standardize_htf_freq(frequency)
+            raise ValueError(
+                "This should never be raised, the above call should error first"
+            )
+
     def early_closes(self, schedule):
         """
         Get a DataFrame of the dates that are an early close.

pandas_market_calendars/calendars/sse.py

@@ -42,7 +42,7 @@ class SSEExchangeCalendar(MarketCalendar):
         # Since all past holidays are adhoc, start_year should always be a year in the future.
         # For example: Holiday arrangements for 2022 are now included,
         # then our guesswork starts from the next year so start_year = 2023
-        start_year = 2024
+        start_year = 2026
 
         return AbstractHolidayCalendar(
             rules=[

pandas_market_calendars/calendars/tase.py

@@ -1,9 +1,11 @@
 from datetime import time
 
-from pandas import Timestamp
+from typing import Literal, Union
+from pandas import Timestamp, Timedelta, DatetimeIndex
 from pytz import timezone
 
 from pandas_market_calendars.market_calendar import MarketCalendar
+from pandas_market_calendars.calendar_utils import Day_Anchor, Month_Anchor
 
 TASEClosedDay = [
     # 2019
@@ -195,3 +197,24 @@ class TASEExchangeCalendar(MarketCalendar):
     @property
     def weekmask(self):
         return "Sun Mon Tue Wed Thu"
+
+    def date_range_htf(
+        self,
+        frequency: Union[str, Timedelta, int, float],
+        start: Union[str, Timestamp, int, float, None] = None,
+        end: Union[str, Timestamp, int, float, None] = None,
+        periods: Union[int, None] = None,
+        closed: Union[Literal["left", "right"], None] = "right",
+        *,
+        day_anchor: Day_Anchor = "SAT",  # Change the default day anchor
+        month_anchor: Month_Anchor = "JAN",
+    ) -> DatetimeIndex:
+        return super().date_range_htf(
+            frequency,
+            start,
+            end,
+            periods,
+            closed,
+            day_anchor=day_anchor,
+            month_anchor=month_anchor,
+        )

pandas_market_calendars/holidays/cn.py

@@ -565,6 +565,7 @@ all_holidays = [
     Timestamp("2023-10-05"),
     Timestamp("2023-10-06"),
     Timestamp("2024-01-01"),
+    Timestamp("2024-02-09"),
     Timestamp("2024-02-12"),
     Timestamp("2024-02-13"),
     Timestamp("2024-02-14"),
@@ -583,6 +584,26 @@ all_holidays = [
     Timestamp("2024-10-03"),
     Timestamp("2024-10-04"),
     Timestamp("2024-10-07"),
+    # 2025 holidays
+    Timestamp("2025-01-01"),  # New Year
+    Timestamp("2025-01-28"),  # Spring Festival
+    Timestamp("2025-01-29"),
+    Timestamp("2025-01-30"),
+    Timestamp("2025-01-31"),
+    Timestamp("2025-02-03"),
+    Timestamp("2025-02-04"),
+    Timestamp("2025-04-04"),  # Tomb-sweeping Day
+    Timestamp("2025-04-05"),
+    Timestamp("2025-05-01"),  # Labor Day
+    Timestamp("2025-05-02"),
+    Timestamp("2025-05-05"),
+    Timestamp("2025-06-02"),  # Dragon Boat Festival
+    Timestamp("2025-10-01"),  # National Day & Mid-autumn Festival
+    Timestamp("2025-10-02"),
+    Timestamp("2025-10-03"),
+    Timestamp("2025-10-06"),
+    Timestamp("2025-10-07"),
+    Timestamp("2025-10-08"),
 ]
 
 # The following holidays are based on Solar terms or Chinese lunisolar calendar,

pandas_market_calendars/holidays/jpx_equinox.py

@@ -11,6 +11,7 @@ from the Tokyo exchange inauguration through 2099,
 using pyephem (http://rhodesmill.org/pyephem/quick.html#equinoxes-solstices).
 For a double check, see:  https://aa.usno.navy.mil/data/docs/EarthSeasons.php
 """
+
 import pandas as pd
 from pandas.tseries.holiday import sunday_to_monday
 

pandas_market_calendars/holidays/nyse.py

@@ -1529,3 +1529,8 @@ HurricaneSandyClosings2012 = [
 GeorgeHWBushDeath2018 = [
     Timestamp("2018-12-05", tz="UTC"),
 ]
+
+# 2025
+JimmyCarterDeath2025 = [
+    Timestamp("2025-01-09", tz="UTC"),
+]