HOME


sh-3ll 1.0
DIR:/usr/local/lib64/python3.6/site-packages/pandas/core/indexes/__pycache__/
Upload File :
Current File : //usr/local/lib64/python3.6/site-packages/pandas/core/indexes/__pycache__/datetimes.cpython-36.pyc
3

���hǑ�@s�ddlmZmZmZmZmZddlZddlmZddlZddl	Z
ddlmZm
Z
mZmZmZddlmZmZmZmZmZddlmZddlmZmZddlmZdd	lm Z m!Z!dd
l"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+ddl,m-Z-m.Z.ddl/j0j1Z2dd
l3m4Z4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;dd�Z<e9ddddge-j=dd�e-j>D�e-dd�e9ddge-dd�e9ddd d!d"d#d$d%d&d'd(d)d*d+ge-j?e-�Gd,d-�d-e7����Z@e@jA�e@jB�d8e@d/�d0d1�ZCd9e@d/�d3d4�ZDeeEd5�d6d7�ZFdS):�)�date�datetime�time�	timedelta�tzinfoN)�Optional)�NaT�Period�	Timestamp�index�lib)�
Resolution�ints_to_pydatetime�parsing�	timezones�	to_offset)�prefix_mapping)�DtypeObj�Label)�InvalidIndexError)�cache_readonly�doc)�DT64NS_DTYPE�is_datetime64_any_dtype�is_datetime64_dtype�is_datetime64tz_dtype�is_float�
is_integer�	is_scalar)�is_valid_nat_for_dtype)�
DatetimeArray�tz_to_dtype)�Index�maybe_extract_name)�DatetimeTimedeltaMixin)�
inherit_names)�to_timec
Cs�d|kr�t|dt�r�|jd�}t|t�sV|jd�}|jd�}tj|t|�|d�}n2|}x,dD]$}||kr`|j|�t||�ks`t�q`W|j|f|�}n,tj	��tj
d�|j|f|�}WdQRX|S)zu
    This is called upon unpickling, rather than the default which doesn't
    have arguments and breaks __new__
    �data�tz�freq)�dtyper)�ignoreN)r(r))�
isinstance�
DatetimeIndex�popr �_simple_newr!�getattr�AssertionError�warnings�catch_warnings�simplefilter�__new__)�cls�dr'r(r)�dta�key�result�r;�?/tmp/pip-build-5_djhm0z/pandas/pandas/core/indexes/datetimes.py�_new_DatetimeIndex(s






r=Zto_perioddeltaZto_julian_date�strftime�isocalendarcCsg|]}|dkr|�qS)�tz_localize)r@r;)�.0�methodr;r;r<�
<listcomp>LsrCT)�wrapZ
is_normalized�_resolution_obj)�cache�	_bool_opsZ_object_ops�
_field_opsZ_datetimelike_ops�_datetimelike_methodsr(rr*Z
to_pydatetime�_has_same_tzZ_format_native_typesrr�timetzc@s�eZdZUdZdZejZdZdddgZ	dddgZ
dZe
eeeej�dEdd
�dd��Zeej�dFdd
�dd��Zd
ejd
dd
d	ddd
dd
fdd�ZedGeed�dd��Zeed
�dd��Zdd�Zdd�Zeed�dd�Z dd�Z!e"d d!��Z#d"d#�Z$d$d%�Z%ejd
d
fd&d'�Z&dHd)d*�Z'e(e)d+�d,d-�Z*e(d.�d/d0�Z+dId1d2�Z,e-d
�d3d4�Z.e/d5�d6d7�Z0dJe/eed8�d9d:�Z1dKd;d<�Z2ed
�d=d>�Z3e"e/d
�d?d@��Z4dLdAdB�Z5dMdCdD�Z6d
S)Nr-u#

    Immutable ndarray-like of datetime64 data.

    Represented internally as int64, and which can be boxed to Timestamp objects
    that are subclasses of datetime and carry metadata.

    Parameters
    ----------
    data : array-like (1-dimensional), optional
        Optional datetime-like data to construct index with.
    freq : str or pandas offset object, optional
        One of pandas date offset strings or corresponding objects. The string
        'infer' can be passed in order to set the frequency of the index as the
        inferred frequency upon creation.
    tz : pytz.timezone or dateutil.tz.tzfile or datetime.tzinfo or str
        Set the Timezone of the data.
    normalize : bool, default False
        Normalize start/end dates to midnight before generating date range.
    closed : {'left', 'right'}, optional
        Set whether to include `start` and `end` that are on the
        boundary. The default includes boundary points on either end.
    ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
        When clocks moved backward due to DST, ambiguous times may arise.
        For example in Central European Time (UTC+01), when going from 03:00
        DST to 02:00 non-DST, 02:30:00 local time occurs both at 00:30:00 UTC
        and at 01:30:00 UTC. In such a situation, the `ambiguous` parameter
        dictates how ambiguous times should be handled.

        - 'infer' will attempt to infer fall dst-transition hours based on
          order
        - bool-ndarray where True signifies a DST time, False signifies a
          non-DST time (note that this flag is only applicable for ambiguous
          times)
        - 'NaT' will return NaT where there are ambiguous times
        - 'raise' will raise an AmbiguousTimeError if there are ambiguous times.
    dayfirst : bool, default False
        If True, parse dates in `data` with the day first order.
    yearfirst : bool, default False
        If True parse dates in `data` with the year first order.
    dtype : numpy.dtype or DatetimeTZDtype or str, default None
        Note that the only NumPy dtype allowed is ‘datetime64[ns]’.
    copy : bool, default False
        Make a copy of input ndarray.
    name : label, default None
        Name to be stored in the index.

    Attributes
    ----------
    year
    month
    day
    hour
    minute
    second
    microsecond
    nanosecond
    date
    time
    timetz
    dayofyear
    weekofyear
    week
    dayofweek
    weekday
    quarter
    tz
    freq
    freqstr
    is_month_start
    is_month_end
    is_quarter_start
    is_quarter_end
    is_year_start
    is_year_end
    is_leap_year
    inferred_freq

    Methods
    -------
    normalize
    strftime
    snap
    tz_convert
    tz_localize
    round
    floor
    ceil
    to_period
    to_perioddelta
    to_pydatetime
    to_series
    to_frame
    month_name
    day_name
    mean

    See Also
    --------
    Index : The base pandas Index type.
    TimedeltaIndex : Index of timedelta64 data.
    PeriodIndex : Index of Period data.
    to_datetime : Convert argument to datetime.
    date_range : Create a fixed-frequency DatetimeIndex.

    Notes
    -----
    To learn more about the frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.
    Z
datetimeindexT�name�freqstrr(r)F�raise)�returncCs$|jj|||�}t|�j||jd�S)N)rL)�_datar@�typer/rL)�selfr(�	ambiguousZnonexistent�arrr;r;r<r@�szDatetimeIndex.tz_localizeNcCs |jj|�}t|�j||jd�S)N)rL)rP�	to_periodrQr/rL)rRr)rTr;r;r<rU�szDatetimeIndex.to_periodc
CsZt|�r"t|j�dt|��d���t|||�}tj||	|
|||||d�}|j||d�}
|
S)Nz2() must be called with a collection of some kind, z was passed)r*�copyr(r)�dayfirst�	yearfirstrS)rL)r�	TypeError�__name__�reprr#r Z_from_sequencer/)r6r'r)r(�	normalize�closedrSrWrXr*rVrL�dtarrZsubarrr;r;r<r5�szDatetimeIndex.__new__)�valuesrLcCsLt|t�stt|���tj|�}||_||_i|_d|_	|j|_
|j�|S)NF)r,r r1rQ�objectr5rPrL�_cacheZ_no_setting_nameZ_index_dataZ_reset_identity)r6r_rLr:r;r;r<r/s
zDatetimeIndex._simple_newcCs ddlm}|jdko||j�S)z�
        Return a boolean if we are only dates (and don't have a timezone)

        Returns
        -------
        bool
        r)�_is_dates_onlyN)�pandas.io.formats.formatrbr(�_values)rRrbr;r;r<rb-s	zDatetimeIndex._is_dates_onlycCs,t|jd�}|j|j��tt|�|fdfS)N)r')�dictrP�updateZ_get_attributes_dictr=rQ)rRr7r;r;r<�
__reduce__:szDatetimeIndex.__reduce__cCs |j|�rt|�jStd��dS)z<
        Convert value to be insertable to ndarray.
        z-Passed item and index have different timezoneN)rJr
Zasm8�
ValueError)rR�valuer;r;r<�_convert_for_opCs

zDatetimeIndex._convert_for_op)r*rOcCs&t|�sdS|jdk	rt|�St|�S)zF
        Can we compare values of the given dtype to our own?
        FN)rr(rr)rRr*r;r;r<�_is_comparable_dtypeKs

z"DatetimeIndex._is_comparable_dtypecCst|j|j�S)N)r�asi8r()rRr;r;r<�	_mpl_reprZszDatetimeIndex._mpl_reprcs&ddlm}|�jd����fdd�S)Nr)�_get_format_datetime64)Z
is_dates_onlycsd�|�jd��d�S)N�')r()r()�x)�	formatterrRr;r<�<lambda>csz/DatetimeIndex._formatter_func.<locals>.<lambda>)rcrnrb)rRrnr;)rqrRr<�_formatter_func^szDatetimeIndex._formatter_funccCs�|}x�|D]x}t|t�s&tj||�}q
t|t�sRyt|�}Wntk
rPYnX|j|�\}}|j|�rv|j|�}q
tj||�}q
W|S)zQ
        A bit of a hack to accelerate unioning a collection of indexes.
        )r,r-r"�unionrYZ_maybe_utc_convertZ_can_fast_unionZ_fast_union)rRZothers�this�otherr;r;r<�
union_manyhs



zDatetimeIndex.union_manycCsF|j}|jdk	r(tj|j�r(|jj�}|d}|d}d	||j<|S)
z}
        Return the number of microseconds since midnight.

        Returns
        -------
        ndarray[int64_t]
        N�iiʚ;i��i�Ql�"R:���)rlr(rZis_utcrPZ_local_timestampsZ_isnan)rRr_Znanos�microsr;r;r<�_get_time_micros�s

zDatetimeIndex._get_time_microscCs�ddlm}|dkr|j�}|dkr*|j}|tjk	r\|rJtjdtdd�q`tjdtdd�nd}|r||j	dk	r||j
dd	�}n|jjd
�j
�}||||d�S)a�
        Create a Series with both index and values equal to the index keys
        useful with map for returning an indexer based on an index.

        Parameters
        ----------
        keep_tz : optional, defaults True
            Return the data keeping the timezone.

            If keep_tz is True:

              If the timezone is not set, the resulting
              Series will have a datetime64[ns] dtype.

              Otherwise the Series will have an datetime64[ns, tz] dtype; the
              tz will be preserved.

            If keep_tz is False:

              Series will have a datetime64[ns] dtype. TZ aware
              objects will have the tz removed.

            .. versionchanged:: 1.0.0
                The default value is now True.  In a future version,
                this keyword will be removed entirely.  Stop passing the
                argument to obtain the future behavior and silence the warning.

        index : Index, optional
            Index of resulting Series. If None, defaults to original index.
        name : str, optional
            Name of resulting Series. If None, defaults to name of original
            index.

        Returns
        -------
        Series
        r)�SeriesNz�The 'keep_tz' keyword in DatetimeIndex.to_series is deprecated and will be removed in a future version.  You can stop passing 'keep_tz' to silence this warning.�)�
stacklevelz�Specifying 'keep_tz=False' is deprecated and this option will be removed in a future release. If you want to remove the timezone information, you can do 'idx.tz_convert(None)' before calling 'to_series'.T)�deepzM8[ns])rrL)
Zpandasr}Z
_shallow_copyrLr�
no_defaultr2�warn�
FutureWarningr(rVrd�view)rRZkeep_tzrrLr}r_r;r;r<�	to_series�s(&


zDatetimeIndex.to_series�Sc	Cs�t|�}tjt|�td�}x`t|�D]T\}}|}|j|�sp|j|�}|j|�}t	||�t	||�krl|}n|}|||<q$Wt
||jd�}tj
||jd�S)zy
        Snap time stamps to nearest occurring frequency.

        Returns
        -------
        DatetimeIndex
        )r*)rL)r�np�empty�lenr�	enumerateZis_on_offset�rollbackZrollforward�absr r*r-r/rL)	rRr)Zsnapped�i�v�s�t0�t1r8r;r;r<�snap�s	


zDatetimeIndex.snap)�reso�parsedc
Cs�t|t�stt|�|f��ddddddddddh
}|j|kr@t�|j}t||d	�}|j|j	}}|j
d
k	r�|jd
kr|td��|j
|j
�j|j�}|j
|j
�j|j�}n"|jd
k	r�|j
|j�}|j
|j�}||fS)aI
        Calculate datetime bounds for parsed time string and its resolution.

        Parameters
        ----------
        reso : str
            Resolution provided by parsed string.
        parsed : datetime
            Datetime from parsed string.

        Returns
        -------
        lower, upper: pd.Timestamp
        �year�monthZquarter�day�hour�minute�second�microsecond)r)NzSThe index must be timezone aware when indexing with a date string with a UTC offset)r,r
r1rQ�attrname�KeyErrorZ
freq_groupr	�
start_time�end_timerr(rhr@�
tz_convert)rRr�r�Zvalid_resos�grpZper�start�endr;r;r<�_parsed_string_to_bounds�s4



z&DatetimeIndex._parsed_string_to_bounds)r�cCsHt|t�stt|�|f��|jr8|jdkr8|j|kr8t�|dkrDt�dS)Nr�r�r�r�r�)r�r�r�r�)r,r
r1rQZis_monotonicr�rEr�)rRr�r;r;r<�_validate_partial_date_slice/s

z*DatetimeIndex._validate_partial_date_slicec&CsLt|�st|��|}t||j�r$t}t||jj�r>|j|�}n�t|t	�r�y
|j
|�Sttt
tfk
rnYnXy|j|�}Wn,t
k
r�}zt|�|�WYdd}~XnXnZt|t�r�tdt|�j�dt|�j����n.t|t��r|dk	r�td��|j|�St|��ytj||||�Stk
�rF}zt|�|�WYdd}~XnXdS)zm
        Get integer location for requested label

        Returns
        -------
        loc : int
        Nz
Cannot index z with z:cannot yet lookup inexact labels when key is a time object)rrrr*rr,rPZ_recognized_scalars�_maybe_cast_for_get_loc�str�_get_string_slicerYr�rh�
OverflowErrorrrQrZr�NotImplementedError�indexer_at_timer"�get_loc)rRr9rBZ	toleranceZorig_key�errr;r;r<r�As:


 
zDatetimeIndex.get_loccCs0t|�}|jdkr |j|j�}n|j|j�}|S)N)r
rr@r(r�)rRr9r;r;r<r�us

z%DatetimeIndex._maybe_cast_for_get_loc)�sidec	Cs�|d	kst�t|�s&t|t�s&t|�r2|jd|�t|t�r�t|dt|dd��}tj	||�\}}t
j|�}|j||�\}}|j
r�t|�dkr�|dkr�|S|S|dkr�|S|S|SdS)
as
        If label is a string, cast it to datetime according to resolution.

        Parameters
        ----------
        label : object
        side : {'left', 'right'}
        kind : {'loc', 'getitem'} or None

        Returns
        -------
        label : object

        Notes
        -----
        Value of `side` parameter should be validated in caller.
        �loc�getitemN�slicerM�
inferred_freqry�left)r�r�N)r1rr,rrZ_invalid_indexerr�r0r�parse_time_stringr
�
from_attrnamer�Z!_is_strictly_monotonic_decreasingr�)	rR�labelr��kindr)r�r��lower�upperr;r;r<�_maybe_cast_slice_bound~s

z%DatetimeIndex._maybe_cast_slice_bound)r9�use_lhs�use_rhscCsDt|dt|dd��}tj||�\}}tj|�}|j||||d�}|S)NrMr�)r�r�)r0rr�r
r�Z_partial_date_slice)rRr9r�r�r)r�r�r�r;r;r<r��s

zDatetimeIndex._get_string_slicec	
Cszt|t�r8t|t�r8|dk	r,|dkr,td��|j||�St|t�sLt|t�rTtd��t|t�r|t|t�r|tj|tdd��}t|t�r�t|t�r�tj|tdd��}ytj	|||||d�Stk
�rt|dks�t|t
�o�|dks�t|t
��rnd}|dk	�r|j|d|�}||k}|dk	�r8|j|d	|�}||k|@}|j�ddd|�}t
|�t
|�k�rhtd�S|Sn�YnXdS)
a�
        Return indexer for specified label slice.
        Index.slice_indexer, customized to handle time slicing.

        In addition to functionality provided by Index.slice_indexer, does the
        following:

        - if both `start` and `end` are instances of `datetime.time`, it
          invokes `indexer_between_time`
        - if `start` and `end` are both either string or None perform
          value-based selection in non-monotonic cases.

        Nryz)Must have step size of 1 with time slicesz'Cannot mix time and non-time slice keysr)r�Tr��right)r,rrh�indexer_between_timer�rr�combiner"�
slice_indexerr�r��nonzeror�r�)	rRr�r��stepr��maskZstart_castedZ
end_castedZindexerr;r;r<r��s6

zDatetimeIndex.slice_indexercCs||jkp|dkS)Nr)�
inferred_type)rR�typr;r;r<�is_type_compatible�sz DatetimeIndex.is_type_compatiblecCsdS)NZ
datetime64r;)rRr;r;r<r��szDatetimeIndex.inferred_typecCsx|rtd��t|t�r.ddlm}||�j�}|jrX|jdkrFtd��|j	|j�j
�}n|j
�}t|�}||kj�dS)a�
        Return index locations of values at particular time of day
        (e.g. 9:30AM).

        Parameters
        ----------
        time : datetime.time or str
            Time passed in either as object (datetime.time) or as string in
            appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
            "%H:%M:%S", "%H%M%S", "%I:%M:%S%p", "%I%M%S%p").

        Returns
        -------
        values_at_time : array of integers

        See Also
        --------
        indexer_between_time : Get index locations of values between particular
            times of day.
        DataFrame.at_time : Select values at particular time of day.
        z 'asof' argument is not supportedr)�parseNzIndex must be timezone aware.)
r�r,r�Zdateutil.parserr�rrr(rhr�r|�_time_to_microsr�)rRrZasofr��time_microsr{r;r;r<r��s

zDatetimeIndex.indexer_at_timecCs�t|�}t|�}|j�}t|�}t|�}|r<|r<tj}}	n.|rNtj}tj}	n|r`tj}tj}	n
tj}}	||krztj}
ntj}
|
|||�|	||��}|j�dS)a�
        Return index locations of values between particular times of day
        (e.g., 9:00-9:30AM).

        Parameters
        ----------
        start_time, end_time : datetime.time, str
            Time passed either as object (datetime.time) or as string in
            appropriate format ("%H:%M", "%H%M", "%I:%M%p", "%I%M%p",
            "%H:%M:%S", "%H%M%S", "%I:%M:%S%p","%I%M%S%p").
        include_start : bool, default True
        include_end : bool, default True

        Returns
        -------
        values_between_time : array of integers

        See Also
        --------
        indexer_at_time : Get index locations of values at particular time of day.
        DataFrame.between_time : Select values between particular times of day.
        r)	r&r|r��operator�le�lt�and_�or_r�)rRr�r�Z
include_startZinclude_endr�Zstart_microsZ
end_microsZlopZropZjoin_opr�r;r;r<r�s&
z"DatetimeIndex.indexer_between_time)rNrN)N)N)r�)NN)TT)NNNN)F)TT)7rZ�
__module__�__qualname__�__doc__Z_typ�libindexZDatetimeEngineZ_engine_typeZ!_supports_partial_string_indexingZ_comparables�_attributesZ_is_numeric_dtyper rPrrr(rr@rUrr�r5�classmethodrr/r�boolrbrgrjrrkrm�propertyrsrwr|r�r�r
rr�r�r�r
r�r�r�r�r�r�r�r�r�r;r;r;r<r-Hsf


		
K
4
4	(
<
(r-F)rOc

KsH|dkrtj|||�rd}tjf|||||||d�|��}	tj|	|d�S)a�
    Return a fixed frequency DatetimeIndex.

    Parameters
    ----------
    start : str or datetime-like, optional
        Left bound for generating dates.
    end : str or datetime-like, optional
        Right bound for generating dates.
    periods : int, optional
        Number of periods to generate.
    freq : str or DateOffset, default 'D'
        Frequency strings can have multiples, e.g. '5H'. See
        :ref:`here <timeseries.offset_aliases>` for a list of
        frequency aliases.
    tz : str or tzinfo, optional
        Time zone name for returning localized DatetimeIndex, for example
        'Asia/Hong_Kong'. By default, the resulting DatetimeIndex is
        timezone-naive.
    normalize : bool, default False
        Normalize start/end dates to midnight before generating date range.
    name : str, default None
        Name of the resulting DatetimeIndex.
    closed : {None, 'left', 'right'}, optional
        Make the interval closed with respect to the given frequency to
        the 'left', 'right', or both sides (None, the default).
    **kwargs
        For compatibility. Has no effect on the result.

    Returns
    -------
    rng : DatetimeIndex

    See Also
    --------
    DatetimeIndex : An immutable container for datetimes.
    timedelta_range : Return a fixed frequency TimedeltaIndex.
    period_range : Return a fixed frequency PeriodIndex.
    interval_range : Return a fixed frequency IntervalIndex.

    Notes
    -----
    Of the four parameters ``start``, ``end``, ``periods``, and ``freq``,
    exactly three must be specified. If ``freq`` is omitted, the resulting
    ``DatetimeIndex`` will have ``periods`` linearly spaced elements between
    ``start`` and ``end`` (closed on both sides).

    To learn more about the frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.

    Examples
    --------
    **Specifying the values**

    The next four examples generate the same `DatetimeIndex`, but vary
    the combination of `start`, `end` and `periods`.

    Specify `start` and `end`, with the default daily frequency.

    >>> pd.date_range(start='1/1/2018', end='1/08/2018')
    DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                   '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
                  dtype='datetime64[ns]', freq='D')

    Specify `start` and `periods`, the number of periods (days).

    >>> pd.date_range(start='1/1/2018', periods=8)
    DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
                   '2018-01-05', '2018-01-06', '2018-01-07', '2018-01-08'],
                  dtype='datetime64[ns]', freq='D')

    Specify `end` and `periods`, the number of periods (days).

    >>> pd.date_range(end='1/1/2018', periods=8)
    DatetimeIndex(['2017-12-25', '2017-12-26', '2017-12-27', '2017-12-28',
                   '2017-12-29', '2017-12-30', '2017-12-31', '2018-01-01'],
                  dtype='datetime64[ns]', freq='D')

    Specify `start`, `end`, and `periods`; the frequency is generated
    automatically (linearly spaced).

    >>> pd.date_range(start='2018-04-24', end='2018-04-27', periods=3)
    DatetimeIndex(['2018-04-24 00:00:00', '2018-04-25 12:00:00',
                   '2018-04-27 00:00:00'],
                  dtype='datetime64[ns]', freq=None)

    **Other Parameters**

    Changed the `freq` (frequency) to ``'M'`` (month end frequency).

    >>> pd.date_range(start='1/1/2018', periods=5, freq='M')
    DatetimeIndex(['2018-01-31', '2018-02-28', '2018-03-31', '2018-04-30',
                   '2018-05-31'],
                  dtype='datetime64[ns]', freq='M')

    Multiples are allowed

    >>> pd.date_range(start='1/1/2018', periods=5, freq='3M')
    DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                   '2019-01-31'],
                  dtype='datetime64[ns]', freq='3M')

    `freq` can also be specified as an Offset object.

    >>> pd.date_range(start='1/1/2018', periods=5, freq=pd.offsets.MonthEnd(3))
    DatetimeIndex(['2018-01-31', '2018-04-30', '2018-07-31', '2018-10-31',
                   '2019-01-31'],
                  dtype='datetime64[ns]', freq='3M')

    Specify `tz` to set the timezone.

    >>> pd.date_range(start='1/1/2018', periods=5, tz='Asia/Tokyo')
    DatetimeIndex(['2018-01-01 00:00:00+09:00', '2018-01-02 00:00:00+09:00',
                   '2018-01-03 00:00:00+09:00', '2018-01-04 00:00:00+09:00',
                   '2018-01-05 00:00:00+09:00'],
                  dtype='datetime64[ns, Asia/Tokyo]', freq='D')

    `closed` controls whether to include `start` and `end` that are on the
    boundary. The default includes boundary points on either end.

    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed=None)
    DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03', '2017-01-04'],
                  dtype='datetime64[ns]', freq='D')

    Use ``closed='left'`` to exclude `end` if it falls on the boundary.

    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='left')
    DatetimeIndex(['2017-01-01', '2017-01-02', '2017-01-03'],
                  dtype='datetime64[ns]', freq='D')

    Use ``closed='right'`` to exclude `start` if it falls on the boundary.

    >>> pd.date_range(start='2017-01-01', end='2017-01-04', closed='right')
    DatetimeIndex(['2017-01-02', '2017-01-03', '2017-01-04'],
                  dtype='datetime64[ns]', freq='D')
    N�D)r�r��periodsr)r(r\r])rL)�comZany_noner Z_generate_ranger-r/)
r�r�r�r)r(r\rLr]�kwargsr^r;r;r<�
date_rangeQsr��Bc

Ks�|dkrd}t|��t|t�r�|jd�r�y|p0d}t|||d�}Wq�ttfk
r~}zd|��}t|�|�WYdd}~Xq�Xn|s�|r�d|��}t|��tf||||||||	d�|
��S)	a�
    Return a fixed frequency DatetimeIndex, with business day as the default
    frequency.

    Parameters
    ----------
    start : str or datetime-like, default None
        Left bound for generating dates.
    end : str or datetime-like, default None
        Right bound for generating dates.
    periods : int, default None
        Number of periods to generate.
    freq : str or DateOffset, default 'B' (business daily)
        Frequency strings can have multiples, e.g. '5H'.
    tz : str or None
        Time zone name for returning localized DatetimeIndex, for example
        Asia/Beijing.
    normalize : bool, default False
        Normalize start/end dates to midnight before generating date range.
    name : str, default None
        Name of the resulting DatetimeIndex.
    weekmask : str or None, default None
        Weekmask of valid business days, passed to ``numpy.busdaycalendar``,
        only used when custom frequency strings are passed.  The default
        value None is equivalent to 'Mon Tue Wed Thu Fri'.
    holidays : list-like or None, default None
        Dates to exclude from the set of valid business days, passed to
        ``numpy.busdaycalendar``, only used when custom frequency strings
        are passed.
    closed : str, default None
        Make the interval closed with respect to the given frequency to
        the 'left', 'right', or both sides (None).
    **kwargs
        For compatibility. Has no effect on the result.

    Returns
    -------
    DatetimeIndex

    Notes
    -----
    Of the four parameters: ``start``, ``end``, ``periods``, and ``freq``,
    exactly three must be specified.  Specifying ``freq`` is a requirement
    for ``bdate_range``.  Use ``date_range`` if specifying ``freq`` is not
    desired.

    To learn more about the frequency strings, please see `this link
    <https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#offset-aliases>`__.

    Examples
    --------
    Note how the two weekend days are skipped in the result.

    >>> pd.bdate_range(start='1/1/2018', end='1/08/2018')
    DatetimeIndex(['2018-01-01', '2018-01-02', '2018-01-03', '2018-01-04',
               '2018-01-05', '2018-01-08'],
              dtype='datetime64[ns]', freq='B')
    Nz>freq must be specified for bdate_range; use date_range instead�CzMon Tue Wed Thu Fri)�holidays�weekmaskz!invalid custom frequency string: zZa custom frequency string is required when holidays or weekmask are passed, got frequency )r�r�r�r)r(r\rLr])rYr,r��
startswithrr�rhr�)
r�r�r�r)r(r\rLr�r�r]r��msgr�r;r;r<�bdate_range�s.G

r�)�time_objrOcCs,|jddd|j|j}d||jS)N�<i@B)r�r�r�r�)r��secondsr;r;r<r�Zsr�)NNNNNFNN)
NNNr�NTNNNN)Grrrrrr�Ztypingrr2Znumpyr�Zpandas._libsrr	r
rr�rZpandas._libs.tslibsr
rrrrZpandas._libs.tslibs.offsetsrZpandas._typingrrZ
pandas.errorsrZpandas.util._decoratorsrrZpandas.core.dtypes.commonrrrrrrrZpandas.core.dtypes.missingrZpandas.core.arrays.datetimesr r!Zpandas.core.common�core�commonr�Zpandas.core.indexes.baser"r#Z pandas.core.indexes.datetimeliker$Zpandas.core.indexes.extensionr%Zpandas.core.tools.timesr&r=rHrIrGr-Z_add_numeric_methods_disabledZ_add_logical_methods_disabledr�r��intr�r;r;r;r<�<module>s�$	 
jZ