pandas-market-calendars 4.1.3__py3-none-any.whl → 4.2.0__py3-none-any.whl

pandas_market_calendars/__init__.py

@@ -1,37 +0,0 @@
-# Fork of Zipline by Quantopian released under MIT license. Original Zipline license below.
-#
-# Copyright 2016 Quantopian, Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import pkg_resources
-
-from .calendar_registry import get_calendar, get_calendar_names
-from .calendar_utils import convert_freq, date_range, merge_schedules
-# TODO: is the below needed? Can I replace all the imports on the calendars with ".market_calendar"
-from .market_calendar import MarketCalendar
-
-# if running in development there may not be a package
-try:
-    __version__ = pkg_resources.get_distribution('pandas_market_calendars').version
-except pkg_resources.DistributionNotFound:
-    __version__ = 'development'
-
-__all__ = [
-    'MarketCalendar',
-    'get_calendar',
-    'get_calendar_names',
-    'merge_schedules',
-    'date_range',
-    'convert_freq'
-]

pandas_market_calendars/calendar_registry.py

@@ -1,47 +0,0 @@
-from .market_calendar import MarketCalendar
-from .exchange_calendar_asx import ASXExchangeCalendar
-from .exchange_calendar_bmf import BMFExchangeCalendar
-from .exchange_calendar_cboe import CFEExchangeCalendar
-from .exchange_calendar_cme import \
-    CMEEquityExchangeCalendar, \
-    CMEBondExchangeCalendar
-from .exchange_calendar_cme_globex_base import CMEGlobexBaseExchangeCalendar
-from .exchange_calendar_cme_globex_agriculture import CMEGlobexAgricultureExchangeCalendar
-from .exchange_calendar_cme_globex_fx import CMEGlobexFXExchangeCalendar
-from .exchange_calendar_cme_globex_energy_and_metals import CMEGlobexEnergyAndMetalsExchangeCalendar
-from .exchange_calendar_cme_globex_equities import CMEGlobexEquitiesExchangeCalendar
-from .exchange_calendar_cme_globex_fixed_income import CMEGlobexFixedIncomeCalendar
-from .exchange_calendar_eurex import EUREXExchangeCalendar
-from .exchange_calendar_hkex import HKEXExchangeCalendar
-from .exchange_calendar_ice import ICEExchangeCalendar
-from .exchange_calendar_iex import IEXExchangeCalendar
-from .exchange_calendar_jpx import JPXExchangeCalendar
-from .exchange_calendar_lse import LSEExchangeCalendar
-from .exchange_calendar_nyse import NYSEExchangeCalendar
-from .exchange_calendar_ose import OSEExchangeCalendar
-from .exchange_calendar_sifma import SIFMAUSExchangeCalendar, SIFMAUKExchangeCalendar, SIFMAJPExchangeCalendar
-from .exchange_calendar_six import SIXExchangeCalendar
-from .exchange_calendar_sse import SSEExchangeCalendar
-from .exchange_calendar_tsx import TSXExchangeCalendar
-from .exchange_calendar_bse import BSEExchangeCalendar
-from .exchange_calendar_tase import TASEExchangeCalendar
-from .exchange_calendars_mirror import *
-
-
-def get_calendar(name, open_time=None, close_time=None):
-    """
-    Retrieves an instance of an MarketCalendar whose name is given.
-
-    :param name: The name of the MarketCalendar to be retrieved.
-    :param open_time: Market open time override as datetime.time object. If None then default is used.
-    :param close_time: Market close time override as datetime.time object. If None then default is used.
-    :return: MarketCalendar of the desired calendar.
-    """
-    return MarketCalendar.factory(name, open_time=open_time, close_time=close_time)
-
-
-def get_calendar_names():
-    """All Market Calendar names and aliases that can be used in "factory"
-    :return: list(str)
-    """
-    return MarketCalendar.calendar_names()

pandas_market_calendars/calendar_utils.py

@@ -1,225 +0,0 @@
-"""
-Utilities to use with market_calendars
-"""
-import itertools
-import warnings
-
-import pandas as pd
-import numpy as np
-
-def merge_schedules(schedules, how='outer'):
-    """
-    Given a list of schedules will return a merged schedule. The merge method (how) will either return the superset
-    of any datetime when any schedule is open (outer) or only the datetime where all markets are open (inner)
-
-    CAVEATS:
-        * This does not work for schedules with breaks, the break information will be lost.
-        * Onlu "market_open" and "market_close" are considered, other market times are not yet supported.
-
-    :param schedules: list of schedules
-    :param how: outer or inner
-    :return: schedule DataFrame
-    """
-    all_cols = [x.columns for x in schedules]
-    all_cols = list(itertools.chain(*all_cols))
-    if ('break_start' in all_cols) or ('break_end' in all_cols):
-        warnings.warn('Merge schedules will drop the break_start and break_end from result.')
-
-    result = schedules[0]
-    for schedule in schedules[1:]:
-        result = result.merge(schedule, how=how, right_index=True, left_index=True)
-        if how == 'outer':
-            result['market_open'] = result.apply(lambda x: min(x.market_open_x, x.market_open_y), axis=1)
-            result['market_close'] = result.apply(lambda x: max(x.market_close_x, x.market_close_y), axis=1)
-        elif how == 'inner':
-            result['market_open'] = result.apply(lambda x: max(x.market_open_x, x.market_open_y), axis=1)
-            result['market_close'] = result.apply(lambda x: min(x.market_close_x, x.market_close_y), axis=1)
-        else:
-            raise ValueError('how argument must be "inner" or "outer"')
-        result = result[['market_open', 'market_close']]
-    return result
-
-
-def convert_freq(index, frequency):
-    """
-    Converts a DateTimeIndex to a new lower frequency
-
-    :param index: DateTimeIndex
-    :param frequency: frequency string
-    :return: DateTimeIndex
-    """
-    return pd.DataFrame(index=index).asfreq(frequency).index
-
-class _date_range:
-    """
-    This is a callable class that should be used by calling the already initiated instance: `date_range`.
-    Given a schedule, it will return a DatetimeIndex with all of the valid datetimes at the frequency given.
-
-    The schedule columns should all have the same time zone.
-
-    The calculations will be made for each trading session. If the passed schedule-DataFrame doesn't have
-    breaks, there is one trading session per day going from market_open to market_close, otherwise there are two,
-    the first one going from market_open to break_start and the second one from break_end to market_close.
-
-    *Any trading session where start == end is considered a 'no-trading session' and will always be dropped*
-
-    CAVEATS:
-        * Only "market_open", "market_close" (and, optionally, "breaak_start" and "break_end")
-            are considered, other market times are not yet supported by this class.
-
-        * If the difference between start and end of a trading session is smaller than an interval of the
-           frequency, and closed= "right" and force_close = False, the whole session will disappear.
-           This will also raise a warning.
-
-
-    Signature:
-    .__call__(self, schedule, frequency, closed='right', force_close=True, **kwargs)
-
-    :param schedule: schedule of a calendar, which may or may not include break_start and break_end columns
-    :param frequency: frequency string that is used by pd.Timedelta to calculate the timestamps
-        this must be "1D" or higher frequency
-    :param closed: the way the intervals are labeled
-        'right': use the end of the interval
-        'left': use the start of the interval
-        None: (or 'both') use the end of the interval but include the start of the first interval (the open)
-    :param force_close: how the last value of a trading session is handled
-        True: guarantee that the close of the trading session is the last value
-        False: guarantee that there is no value greater than the close of the trading session
-        None: leave the last value as it is calculated based on the closed parameter
-    :param kwargs: unused. Solely for compatibility.
-
-
-    """
-
-    def __init__(self, schedule = None, frequency= None, closed='right', force_close=True):
-        if not closed in ("left", "right", "both", None):
-            raise ValueError("closed must be 'left', 'right', 'both' or None.")
-        elif not force_close in (True, False, None):
-            raise ValueError("force_close must be True, False or None.")
-
-        self.closed = closed
-        self.force_close = force_close
-        self.has_breaks = False
-        if frequency is None: self.frequency = None
-        else:
-            self.frequency = pd.Timedelta(frequency)
-            if self.frequency > pd.Timedelta("1D"):
-                raise ValueError('Frequency must be 1D or higher frequency.')
-
-            elif schedule.market_close.lt(schedule.market_open).any():
-                raise ValueError("Schedule contains rows where market_close < market_open,"
-                                 " please correct the schedule")
-
-            if "break_start" in schedule:
-                if not all([
-                    schedule.market_open.le(schedule.break_start).all(),
-                    schedule.break_start.le(schedule.break_end).all(),
-                    schedule.break_end.le(schedule.market_close).all()]):
-                    raise ValueError("Not all rows match the condition: "
-                                     "market_open <= break_start <= break_end <= market_close, "
-                                     "please correct the schedule")
-                self.has_breaks = True
-
-    def _check_overlap(self, schedule):
-        """checks if calculated end times would overlap with the next start times.
-        Only an issue when force_close is None and closed != left.
-
-        :param schedule: pd.DataFrame with first column: 'start' and second column: 'end'
-        :raises ValueError:"""
-        if self.force_close is None and self.closed != "left":
-            num_bars = self._calc_num_bars(schedule)
-            end_times = schedule.start + num_bars * self.frequency
-
-            if end_times.gt(schedule.start.shift(-1)).any():
-                raise ValueError(f"The chosen frequency will lead to overlaps in the calculated index. "
-                                 f"Either choose a higher frequency or avoid setting force_close to None "
-                                 f"when setting closed to 'right', 'both' or None.")
-
-    def _check_disappearing_session(self, schedule):
-        """checks if requested frequency and schedule would lead to lost trading sessions.
-        Only necessary when force_close = False and closed = "right".
-
-        :param schedule: pd.DataFrame with first column: 'start' and second column: 'end'
-        :raises UserWarning:"""
-        if self.force_close is False and self.closed == "right":
-
-            if (schedule.end- schedule.start).lt(self.frequency).any():
-                warnings.warn("An interval of the chosen frequency is larger than some of the trading sessions, "
-                          "while closed== 'right' and force_close is False. This will make those trading sessions "
-                          "disappear. Use a higher frequency or change the values of closed/force_close, to "
-                          "keep this from happening.")
-
-    def _calc_num_bars(self, schedule):
-        """calculate the number of timestamps needed for each trading session.
-
-        :param schedule: pd.DataFrame with first column: 'start' and second column: 'end'
-        :return: pd.Series of float64"""
-        return np.ceil((schedule.end - schedule.start) / self.frequency)
-
-
-    def _calc_time_series(self, schedule):
-        """Method used by date_range to calculate the trading index.
-
-         :param schedule: pd.DataFrame with first column: 'start' and second column: 'end'
-         :return: pd.Series of datetime64[ns, UTC]"""
-        num_bars = self._calc_num_bars(schedule)
-
-        # ---> calculate the desired timeseries:
-        if self.closed == "left":
-            opens = schedule.start.repeat(num_bars)   # keep as is
-            time_series = (opens.groupby(opens.index).cumcount()) * self.frequency + opens
-        elif self.closed == "right":
-            opens = schedule.start.repeat(num_bars)   # dont add row but shift up
-            time_series = (opens.groupby(opens.index).cumcount()+ 1) * self.frequency + opens
-        else:
-            num_bars += 1
-            opens = schedule.start.repeat(num_bars)   # add row but dont shift up
-            time_series = (opens.groupby(opens.index).cumcount()) * self.frequency + opens
-
-        if not self.force_close is None:
-            time_series = time_series[time_series.le(schedule.end.repeat(num_bars))]
-            if self.force_close:
-                time_series = pd.concat([time_series, schedule.end]).sort_values()
-
-        return time_series
-
-
-    def __call__(self, schedule, frequency, closed='right', force_close=True, **kwargs):
-        """
-        See class docstring for more information.
-
-        :param schedule: schedule of a calendar, which may or may not include break_start and break_end columns
-        :param frequency: frequency string that is used by pd.Timedelta to calculate the timestamps
-            this must be "1D" or higher frequency
-        :param closed: the way the intervals are labeled
-            'right': use the end of the interval
-            'left': use the start of the interval
-            None: (or 'both') use the end of the interval but include the start of the first interval
-        :param force_close: how the last value of a trading session is handled
-            True: guarantee that the close of the trading session is the last value
-            False: guarantee that there is no value greater than the close of the trading session
-            None: leave the last value as it is calculated based on the closed parameter
-        :param kwargs: unused. Solely for compatibility.
-        :return: pd.DatetimeIndex of datetime64[ns, UTC]
-        """
-        self.__init__(schedule, frequency, closed, force_close)
-        if self.has_breaks:
-            # rearrange the schedule, to make every row one session
-            before = schedule[["market_open", "break_start"]].set_index(schedule["market_open"])
-            after = schedule[["break_end", "market_close"]].set_index(schedule["break_end"])
-            before.columns = after.columns = ["start", "end"]
-            schedule = pd.concat([before, after]).sort_index()
-
-        else:
-            schedule = schedule.rename(columns= {"market_open": "start", "market_close": "end"})
-
-        schedule = schedule[schedule.start.ne(schedule.end)] # drop the 'no-trading sessions'
-        self._check_overlap(schedule)
-        self._check_disappearing_session(schedule)
-
-        time_series = self._calc_time_series(schedule)
-
-        time_series.name = None
-        return pd.DatetimeIndex(time_series.drop_duplicates())
-
-date_range = _date_range()

pandas_market_calendars/class_registry.py

@@ -1,111 +0,0 @@
-import inspect
-from pprint import pformat
-
-def _regmeta_instance_factory(cls, name, *args, **kwargs):
-    """
-    :param cls(RegisteryMeta): registration meta class
-    :param name(str): name of class that needs to be instantiated
-    :param args(Optional(tuple)): instance positional arguments
-    :param kwargs(Optional(dict)): instance named arguments
-    :return: class instance
-    """
-    try:
-        class_ = cls._regmeta_class_registry[name]
-    except KeyError:
-        raise RuntimeError(
-            'Class {} is not one of the registered classes: {}'.format(name, cls._regmeta_class_registry.keys()))
-    return class_(*args, **kwargs)
-
-def _regmeta_register_class(cls, regcls, name):
-    """
-    :param cls(RegisteryMeta): registration base class
-    :param regcls(class): class to be registered
-    :param name(str): name of the class to be registered
-    """
-    if hasattr(regcls, 'aliases'):
-        if regcls.aliases:
-            for alias in regcls.aliases:
-                cls._regmeta_class_registry[alias] = regcls
-        else:
-            cls._regmeta_class_registry[name] = regcls
-    else:
-        cls._regmeta_class_registry[name] = regcls
-
-
-class RegisteryMeta(type):
-    """
-    Metaclass used to register all classes inheriting from RegisteryMeta
-    """
-
-    def __new__(mcs, name, bases, attr):
-        cls = super(RegisteryMeta, mcs).__new__(mcs, name, bases, attr)
-        if not hasattr(cls, '_regmeta_class_registry'):
-            cls._regmeta_class_registry = {}
-            cls.factory = classmethod(_regmeta_instance_factory)
-
-        return cls
-
-    def __init__(cls, name, bases, attr):
-        if not inspect.isabstract(cls):
-            _regmeta_register_class(cls, cls, name)
-            for b in bases:
-                if hasattr(b, '_regmeta_class_registry'):
-                    _regmeta_register_class(b, cls, name)
-
-        super(RegisteryMeta, cls).__init__(name, bases, attr)
-
-        cls.regular_market_times = ProtectedDict(cls.regular_market_times)
-        cls.open_close_map = ProtectedDict(cls.open_close_map)
-
-        cls.special_market_open = cls.special_opens
-        cls.special_market_open_adhoc = cls.special_opens_adhoc
-
-        cls.special_market_close = cls.special_closes
-        cls.special_market_close_adhoc = cls.special_closes_adhoc
-
-
-class ProtectedDict(dict):
-
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # __init__ is bypassed when unpickling, which causes __setitem__ to fail
-        # without the _INIT_RAN_NORMALLY flag
-        self._INIT_RAN_NORMALLY = True
-
-    def _set(self, key, value):
-        return super().__setitem__(key, value)
-
-    def _del(self, key):
-        return super().__delitem__(key)
-
-    def __setitem__(self, key, value):
-        if not hasattr(self, "_INIT_RAN_NORMALLY"):
-            return self._set(key, value)
-
-        raise TypeError("You cannot set a value directly, you can change regular_market_times "
-                        "using .change_time, .add_time or .remove_time.")
-
-    def __delitem__(self, key):
-        if not hasattr(self, "_INIT_RAN_NORMALLY"):
-            return self._del(key)
-
-        raise TypeError("You cannot delete an item directly. You can change regular_market_times "
-                        "using .change_time, .add_time or .remove_time")
-
-    def __repr__(self):
-        return self.__class__.__name__+ "(" + super().__repr__() + ")"
-
-    def __str__(self):
-        try:
-            formatted = pformat(dict(self), sort_dicts= False) # sort_dicts apparently not available < python3.8
-        except TypeError:
-            formatted = pformat(dict(self))
-
-        return self.__class__.__name__+ "(\n" + formatted + "\n)"
-
-    def copy(self):
-        return self.__class__(super().copy())
-
-
-
-

pandas_market_calendars/exchange_calendar_asx.py

@@ -1,63 +0,0 @@
-from datetime import time
-
-from pandas.tseries.holiday import AbstractHolidayCalendar, GoodFriday, EasterMonday
-from pytz import timezone
-
-from .holidays_oz import *
-from .market_calendar import MarketCalendar
-
-AbstractHolidayCalendar.start_date = '2011-01-01'
-
-
-class ASXExchangeCalendar(MarketCalendar):
-	"""
-	Open Time: 10:00 AM, Australia/Sydney
-	Close Time: 4:10 PM, Australia/Sydney
-
-
-	Regularly-Observed Holidays:
-	- New Year's Day (observed on Monday when Jan 1 is a Saturday or Sunday)
-	- Australia Day (observed on Monday when Jan 26 is a Saturday or Sunday)
-	- Good Friday (two days before Easter Sunday)
-	- Easter Monday (the Monday after Easter Sunday)
-	- ANZAC Day (April 25)
-	- Queen's Birthday (second Monday in June)
-	- Christmas Day (December 25, Saturday/Sunday to Monday)
-	- Boxing Day (December 26, Saturday to Monday, Sunday to Tuesday)
-
-
-	Regularly-Observed Early Closes:
-	- Last Business Day before Christmas Day
-	- Last Business Day of the Year
-
-	"""
-	aliases = ['ASX']
-	regular_market_times = {
-		"market_open": ((None, time(10)),),
-		"market_close": ((None, time(16,10)),)
-	}
-
-	@property
-	def name(self):
-		return "ASX"
-
-	@property
-	def tz(self):
-		return timezone("Australia/Sydney")
-
-	@property
-	def regular_holidays(self):
-		return AbstractHolidayCalendar(rules=[
-			OZNewYearsDay,
-			AustraliaDay,
-			AnzacDay,
-			QueensBirthday,
-			Christmas,
-			BoxingDay,
-			GoodFriday,
-			EasterMonday,
-		])
-
-	@property
-	def adhoc_holidays(self):
-		return UniqueCloses