
    Eg\                      d dl mZ d dlmZmZ d dlmZ d dlZd dlmZm	Z	m
Z
mZmZmZmZmZ d dlZd dlZd dlmZmZ d dlmZ d dlmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) d d	l*m+Z+m,Z, d d
l-m.Z. d dl/m0Z0 d dl1m2Z2 d dl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZC d dlDmEZF d dlGmHZHmIZImJZJ d dlKmLZLmMZMmNZN d dlOmPZP d dlQmRZR d dlSmTZTmUZUmVZVmWZWmXZXmYZY d dlZm[Z[m\Z\m]Z]m^Z^m_Z_ d dl`maZambZb d dlcmdZdmeZe d dlfmgZgmhZhmiZimjZj d dlkmlZlmmZmmnZn d dlompZp d dlqmrZr d dlsmtZtmuZu d dlvmwZw d dlxmyZy d dlzm{Z{ d dl|m}c m~Z d dlmZmZmZ d d lmZmZ d d!lmZ d d"lmZmZ d d#lmZ erd d$lmZmZ d d%lmZ d d&lmZmZmZ ee6ef         ZdMd)ZdNd-Z G d. d/eret          Z G d0 d1e          Zd2Zd3Zd4Zd5Z G d6 d7e          ZdOd<ZedPd?            ZedQdB            ZdRdEZdSdIZdTdLZdS )U    )annotations)datetime	timedelta)wrapsN)TYPE_CHECKINGAnyCallableLiteralUnioncastfinaloverload)algoslib)NDArrayBacked)
BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod
ResolutionTick	Timedelta	Timestampadd_overflowsafeastype_overflowsafeget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedeltaperiods_per_day	to_offset)RoundToround_nsint64)compare_mismatched_resolutions)get_unit_for_round)integer_op_not_supported)	ArrayLikeAxisIntDatetimeLikeScalarDtypeDtypeObjFInterpolateOptionsNpDtypePositionalIndexer2DPositionalIndexerTupleScalarIndexerSelfSequenceIndexerTimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparisonPerformanceWarning)AppenderSubstitutioncache_readonly)find_stack_level)'construct_1d_object_array_from_listlike)is_all_stringsis_integer_dtypeis_list_likeis_object_dtypeis_string_dtypepandas_dtype)
ArrowDtypeCategoricalDtypeDatetimeTZDtypeExtensionDtypePeriodDtype)ABCCategoricalABCMultiIndex)is_valid_na_for_dtypeisna)
algorithmsmissingnanopsops)isin	map_arrayunique1d)datetimelike_accumulations)OpsMixin)NDArrayBackedExtensionArrayravel_compat)ArrowExtensionArray)ExtensionArray)IntegerArray)arrayensure_wrapped_if_datetimelikeextract_array)check_array_indexercheck_setitem_lengths)unpack_zerodim_and_defer)invalid_comparisonmake_invalid_op)frequencies)IteratorSequenceIndex)DatetimeArrayPeriodArrayTimedeltaArrayop_namestrc                P    t          |           } t          |           |          S N)re   rc   )rn   ops     T/var/www/sysmax/venv/lib/python3.11/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_oprt      s(    		!	!B,#G,,R000    methr-   returnc                b     t                      fd            }t          t          |          S )z
    For PeriodArray methods, dispatch to DatetimeArray and re-wrap the results
    in PeriodArray.  We cannot use ._ndarray directly for the affected
    methods because the i8 data has different semantics on NaT values.
    c                d   t          | j        t                    s | g|R i |S |                     d          } |g|R i |}|t          u rt          S t          |t
                    r|                     |j                  S |                    d          }|                     |          S )NM8[ns]i8)	
isinstancedtyperK   viewr   r   	_box_func_value_from_backing_data)selfargskwargsarrresultres_i8rv   s         rs   new_methz"_period_dispatch.<locals>.new_meth   s    $*k22 	/4.t...v...ii!!c+D+++F++S==J	** 	1>>&-000T""&&v...ru   )r   r   r-   )rv   r   s   ` rs   _period_dispatchr      s@     4[[/ / / / [/ 8ru   c                      e Zd ZU dZded<   ded<   ded<   ded	<   d
ed<   edd            Z	 dddZedd            Z	ddZ
ddZddZd  Zdd!Zdd#Zedd%            Zd&dd'dd+Zddd-Zddd/Zedd2            Zedd5            Zd fd9Zdd:ZdÈ fd=Zdd>Zddƈ fd@ZeddA            ZeddD            ZeddG            ZedddJ            Zddˈ fdKZdL Zdd?dMddPZdddQZdddSZdT Ze ddV            Z!e"ddW            Z#ddZZ$dd[Z%edd\            Z&edd]            Z'e(dfdd_Z)edda            Z*eddb            Z+eddd            Z,edde            Z-eddf            Z.eddg            Z/eddh            Z0di Z1 e2dj          Z3 e2dk          Z4 e2dl          Z5 e2dm          Z6 e2dn          Z7 e2do          Z8 e2dp          Z9 e2dq          Z: e2dr          Z; e2ds          Z< e2dt          Z= e2du          Z>e ddw            Z?e ddx            Z@e ddy            ZAe ddz            ZBe dd|            ZCe dd}            ZDe dd            ZEe dd            ZFd ZGd ZHddZIe dd            ZJe d             ZKe d             ZLe dd            ZMe dd            ZNd?dddZO ePd          d             ZQd ZR ePd          d             ZSd ZTddZUddZVeWd fd            ZXeWdd?ddd            ZYeWdd?ddd            ZZd?ddddZ[eWdd?ddd            Z\dddZ]ddZ^ xZ_S )DatetimeLikeArrayMixinz
    Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray

    Assumes that __new__/__init__ defines:
        _ndarray

    and that inheriting subclass implements:
        freq
    ztuple[str, ...]_infer_matcheszCallable[[DtypeObj], bool]_is_recognized_dtypeztuple[type, ...]_recognized_scalars
np.ndarray_ndarrayBaseOffset | Nonefreqrw   boolc                    dS )NT r   s    rs   _can_hold_naz#DatetimeLikeArrayMixin._can_hold_na   s    tru   NFr}   Dtype | NonecopyNonec                     t          |           rq   r9   )r   datar}   r   r   s        rs   __init__zDatetimeLikeArrayMixin.__init__   s     "$'''ru   type[DatetimeLikeScalar]c                     t          |           )z
        The scalar associated with this datelike

        * PeriodArray : Period
        * DatetimeArray : Timestamp
        * TimedeltaArray : Timedelta
        r   r   s    rs   _scalar_typez#DatetimeLikeArrayMixin._scalar_type   s     "$'''ru   valuero   DTScalarOrNaTc                     t          |           )ay  
        Construct a scalar type from a string.

        Parameters
        ----------
        value : str

        Returns
        -------
        Period, Timestamp, or Timedelta, or NaT
            Whatever the type of ``self._scalar_type`` is.

        Notes
        -----
        This should call ``self._check_compatible_with`` before
        unboxing the result.
        r   r   r   s     rs   _scalar_from_stringz*DatetimeLikeArrayMixin._scalar_from_string       $ "$'''ru   )np.int64 | np.datetime64 | np.timedelta64c                     t          |           )a  
        Unbox the integer value of a scalar `value`.

        Parameters
        ----------
        value : Period, Timestamp, Timedelta, or NaT
            Depending on subclass.

        Returns
        -------
        int

        Examples
        --------
        >>> arr = pd.array(np.array(['1970-01-01'], 'datetime64[ns]'))
        >>> arr._unbox_scalar(arr[0])
        numpy.datetime64('1970-01-01T00:00:00.000000000')
        r   r   s     rs   _unbox_scalarz$DatetimeLikeArrayMixin._unbox_scalar   s    * "$'''ru   otherc                     t          |           )a|  
        Verify that `self` and `other` are compatible.

        * DatetimeArray verifies that the timezones (if any) match
        * PeriodArray verifies that the freq matches
        * Timedelta has no verification

        In each case, NaT is considered compatible.

        Parameters
        ----------
        other

        Raises
        ------
        Exception
        r   r   r   s     rs   _check_compatible_withz-DatetimeLikeArrayMixin._check_compatible_with  r   ru   c                     t          |           )zI
        box function to get object from internal representation
        r   )r   xs     rs   r   z DatetimeLikeArrayMixin._box_func-  s     "$'''ru   c                :    t          j        || j        d          S )z1
        apply box func to passed values
        F)convert)r   	map_inferr   )r   valuess     rs   _box_valuesz"DatetimeLikeArrayMixin._box_values3  s     }VT^UCCCCru   rg   c                      j         dk    r( fdt          t                               D             S  fd j        D             S )N   c              3  (   K   | ]}|         V  d S rq   r   ).0nr   s     rs   	<genexpr>z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>;  s'      66DG666666ru   c              3  B   K   | ]}                     |          V  d S rq   )r   )r   vr   s     rs   r   z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>=  s/      99!DNN1%%999999ru   )ndimrangelenasi8r   s   `rs   __iter__zDatetimeLikeArrayMixin.__iter__9  sR    9q==6666U3t99%5%566669999ty9999ru   npt.NDArray[np.int64]c                6    | j                             d          S )z
        Integer representation of the values.

        Returns
        -------
        ndarray
            An ndarray with int64 dtype.
        r{   )r   r~   r   s    rs   r   zDatetimeLikeArrayMixin.asi8?  s     }!!$'''ru   r   )na_repdate_formatr   str | floatnpt.NDArray[np.object_]c                    t          |           )z|
        Helper method for astype when converting to strings.

        Returns
        -------
        ndarray[str]
        r   )r   r   r   s      rs   _format_native_typesz+DatetimeLikeArrayMixin._format_native_typesO  s     "$'''ru   boxedc                    dj         S )Nz'{}')format)r   r   s     rs   
_formatterz!DatetimeLikeArrayMixin._formatter[  s
    }ru   NpDtype | Nonec                ~    t          |          r(t          j        t          |           t                    S | j        S )Nr}   )rD   npr^   listobjectr   r   r}   s     rs   	__array__z DatetimeLikeArrayMixin.__array__b  s5    5!! 	68DJJf5555}ru   itemr2   c                    d S rq   r   r   r   s     rs   __getitem__z"DatetimeLikeArrayMixin.__getitem__h      ru   (SequenceIndexer | PositionalIndexerTupler3   c                    d S rq   r   r   s     rs   r   z"DatetimeLikeArrayMixin.__getitem__l  s	    
 	ru   keyr0   Self | DTScalarOrNaTc                    t          dt                                          |                    }t          j        |          r|S t          t
          |          }|                     |          |_        |S )z
        This getitem defers to the underlying array, which by-definition can
        only handle list-likes, slices, and integer scalars
        zUnion[Self, DTScalarOrNaT])r   superr   r   	is_scalarr3   _get_getitem_freq_freq)r   r   r   	__class__s      rs   r   z"DatetimeLikeArrayMixin.__getitem__s  si     2EGG4G4G4L4LMM=   	(M $''F--c22ru   c                   t          | j        t                    }|r| j        }n| j        dk    rd}nt          | |          }d}t          |t                    r&| j        |j        |j        | j        z  }n| j        }n|t          u r| j        }not          j
        |          r[t          j        |                    t          j                            }t          |t                    r|                     |          S |S )z\
        Find the `freq` attribute to assign to the result of a __getitem__ lookup.
        r   N)r|   r}   rK   r   r   ra   slicestepEllipsiscomis_bool_indexerr   maybe_booleans_to_slicer~   r   uint8r   )r   r   	is_periodr   new_keys        rs   r   z(DatetimeLikeArrayMixin._get_getitem_freq  s     tz;77	 	;9DDY!^^DD%dC00CD#u%% ;9(SX-A8di/DD9DD y$S)) ;5chhrx6H6HIIgu-- ;11':::ru   ,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]c                    t          |||           }t                                          ||           |rd S |                                  d S rq   )rb   r   __setitem___maybe_clear_freq)r   r   r   no_opr   s       rs   r   z"DatetimeLikeArrayMixin.__setitem__  sW     &c5$77 	C''' 	F     ru   c                    d S rq   r   r   s    rs   r   z(DatetimeLikeArrayMixin._maybe_clear_freq  s	     	ru   Tc                   t          |          }|t          k    r| j        j        dk    r6t	          d|           } | j        }t          || j        d| j                  }|S | j        j        dk    rt          | j
        d          S |                     | j                                                                      | j                  S t          |t                     r#t#                                          ||          S t'          |          r|                                 S |j        d	v rJ| j        }|t*          j        k    rt/          d
| j         d| d          |r|                                }|S |j        dv r| j        |k    s|j        dk    r)dt3          |           j         d| }t/          |          t+          j        | |          S )NMrk   	timestamp)tzboxresomT)r   r   iuzConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadmMfzCannot cast z
 to dtype r   )rF   r   r}   kindr   r   r   r   _cresor    r   r   ravelreshapeshaper|   rJ   r   astyperE   r   r   int64	TypeErrorr   type__name__asarray)r   r}   r   i8data	convertedr   msgr   s          rs   r  zDatetimeLikeArrayMixin.astype  s   
 U##F??z#%%OT22 .w#	  	 ! C''*4=dCCCC##DIOO$5$566>>tzJJJ~.. 	177>>%d>333U## 	1,,...Z4 YF  Ctz C Cu C C C  
  'MjD  TZ5%8%8UZ3=N=N Hd!4GGGGCC.. :d%0000ru   c                    d S rq   r   r   s    rs   r~   zDatetimeLikeArrayMixin.view  r   ru   Literal['M8[ns]']rk   c                    d S rq   r   r   s     rs   r~   zDatetimeLikeArrayMixin.view  r   ru   Literal['m8[ns]']rm   c                    d S rq   r   r   s     rs   r~   zDatetimeLikeArrayMixin.view  r   ru   .r(   c                    d S rq   r   r   s     rs   r~   zDatetimeLikeArrayMixin.view  r   ru   c                F    t                                          |          S rq   )r   r~   )r   r}   r   s     rs   r~   zDatetimeLikeArrayMixin.view  s     ww||E"""ru   c                   t          |t                    r;	 |                     |          }n$# t          t          f$ r t          |          w xY wt          || j                  s	|t          u rU|                     |          }	 | 	                    |           n# t          t          f$ r}t          |          |d }~ww xY wt          |          st          |          t          |          t          |           k    rt          d          	 |                     |d          }| 	                    |           nM# t          t          f$ r9}t          t          |dd                     rnt          |          |Y d }~nd }~ww xY w|S )NzLengths must matchT)allow_objectr}   )r|   ro   r   
ValueErrorr   r:   r   r   r   r   r	  rC   r   _validate_listlikerD   getattr)r   r   errs      rs   _validate_comparison_valuez1DatetimeLikeArrayMixin._validate_comparison_value
  s   eS!! 	//0077 56 / / /'.../ eT566 	<%3,,%%e,,E8++E222245 8 8 8'..C78 e$$ 	<#E***ZZ3t99$$1222<//D/II++E222245 < < <"75'4#@#@AA <+E22; DDDD< s9   - !AB C,B<<C,D? ?F	/FF	)allow_listlikeunboxr  r  c               l   t          || j                  rnt          |t                    rO	 |                     |          }n# t          $ r+}|                     ||          }t          |          |d}~ww xY wt          || j                  rt          }nt          |          r%|                     ||          }t          |          t          || j                  r|                     |          }n%|                     ||          }t          |          |s|S |                     |          S )a  
        Validate that the input value can be cast to our scalar_type.

        Parameters
        ----------
        value : object
        allow_listlike: bool, default False
            When raising an exception, whether the message should say
            listlike inputs are allowed.
        unbox : bool, default True
            Whether to unbox the result before returning.  Note: unbox=False
            skips the setitem compatibility check.

        Returns
        -------
        self._scalar_type or NaT
        N)r|   r   ro   r   r  _validation_error_messager	  rN   r}   r   rO   r   r   )r   r   r  r  r  r  s         rs   _validate_scalarz'DatetimeLikeArrayMixin._validate_scalar.  sJ   0 eT.// 	!s## 	!.0077 . . .44UNKKnn#-. #5$*55 	!EE%[[ 	! 00GGCC.. t788 	! %%e,,EE 00GGCC..  	 L!!%(((s   A 
A9&A44A9c                    t          |d          r t          |dd          dk    r|j         d}ndt          |          j         d}|rd| j        j         d| d}nd| j        j         d	| d}|S )
a+  
        Construct an exception message on validation error.

        Some methods allow only scalar inputs, while others allow either scalar
        or listlike.

        Parameters
        ----------
        allow_listlike: bool, default False

        Returns
        -------
        str
        r}   r   r   z array'zvalue should be a 'z!', 'NaT', or array of those. Got z	 instead.z' or 'NaT'. Got )hasattrr  r}   r
  r  r   )r   r   r  msg_gotr  s        rs   r!  z0DatetimeLikeArrayMixin._validation_error_messagek  s     5'"" 	2wufa'@'@1'D'D,,,GG1$u++.111G 		=d&7&@ = =*1= = = C*d&7&@ * ** * *  
ru   r  c                8   t          |t          |                     r.| j        j        dv r|s|                    | j        d          }|S t          |t                    r<t          |          dk    r)t          |                               g | j                  S t          |d          r|j        t          k    rt          j        |          | j        v rd	 t          |                               |          }n@# t          t          f$ r, |r|cY S |                     |d          }t          |          w xY wt#          |d          }t%          |          }t#          |d          }t'          |          r;	 t          |                               || j                  }n# t          $ r Y nw xY wt          |j        t(                    r:|j        j        | j        k    r%|                                }t#          |d          }|rt/          |j                  rnLt          |                               |j                  s%|                     |d          }t          |          | j        j        dv r|s|                    | j        d          }|S )	Nr   Fround_okr   r   r}   Textract_numpy)r|   r
  r}   r  as_unitunitr   r   _from_sequencer%  r   r   infer_dtyper   r  r	  r!  r`   pd_arrayrA   rH   
categories_internal_get_valuesrD   r   )r   r   r  r  s       rs   r  z)DatetimeLikeArrayMixin._validate_listlike  s   eT$ZZ(( 	z$&&|&di%@@LeT"" 	Cs5zzQ::,,Rtz,BBB5'"" 
	)u{f'<'< u%%)<<<) JJ55e<<EE"I. ) ) )# %$88EEC#C..(	) e4888e4888%   	 T

11%tz1JJ    ek#344 	A%332244%e4@@@ 	!OEK88 	!d00== 	!00==CC.. :?d""<"MM$)eM<<Es$   "C< <D9&D9=)F' '
F43F4c                    t          |          r|                     |          }n|                     |d          S |                     |          S )NT)r  )rC   r  r"  _unboxr   s     rs   _validate_setitem_valuez.DatetimeLikeArrayMixin._validate_setitem_value  sS     	E++E22EE((t(DDD{{5!!!ru   6np.int64 | np.datetime64 | np.timedelta64 | np.ndarrayc                    t          j        |          r|                     |          }n|                     |           |j        }|S )zZ
        Unbox either a scalar with _unbox_scalar or an instance of our own type.
        )r   r   r   r   r   r   s     rs   r4  zDatetimeLikeArrayMixin._unbox  sM    
 = 	#&&u--EE ''...NEru   c                    ddl m} t          | ||          } ||          }t          |t                    r|                                S |j        S )Nr   ri   )	na_action)pandasrj   rU   r|   rM   to_numpyr^   )r   mapperr9  rj   r   s        rs   mapzDatetimeLikeArrayMixin.map  s_          49===vfm,, 	 ??$$$<ru   r   npt.NDArray[np.bool_]c                   |j         j        dv r t          j        | j        t
                    S t          |          }t          |t          |                     sOg d}|j         t          k    rt          j        |d| j                   }|j         t          k    r|                     |          S t          j        |d          }||vrS|dk    rnLd	|v r(t          |                     t                    |          S t          j        | j        t
                    S 	 t          |                               |          }t!          j        d
| j          dt$          t'                                 n8# t(          $ r+ t          |                     t                    |          cY S w xY w| j         j        dv r*t+          d|           } |                    | j                  }	 |                     |           n7# t2          t(          f$ r# t          j        | j        t
                    cY S w xY wt          | j        |j                  S )z
        Compute boolean array of whether each value is found in the
        passed set of values.

        Parameters
        ----------
        values : np.ndarray or ExtensionArray

        Returns
        -------
        ndarray[bool]
        fiucr   )r   timedelta64r   
datetime64dateperiodT)convert_non_numericdtype_if_all_natFskipnastringmixedz"The behavior of 'isin' with dtype=z and castable values (e.g. strings) is deprecated. In a future version, these will not be considered matching by isin. Explicitly cast to the appropriate dtype before calling isin instead.
stacklevelr   DatetimeArray | TimedeltaArray)r}   r  r   zerosr  r   r_   r|   r
  r   r   maybe_convert_objectsrT   r/  r  r.  warningswarnFutureWarningr?   r  r   r,  r-  r   r	  r   )r   r   	inferableinferreds       rs   rT   zDatetimeLikeArrayMixin.isin  sh    <&&8DJd3333/77&$t**-- *	  I |v%%2(,%)Z  
 <6))99V,,,?6%@@@9,,8++ H,,#DKK$7$7@@@!x
$????d226:: , , , ,
 "/11	 	 	 	 	  9 9 9DKK//888889 :?d""8$??D ^^DI..F	4 ''////:& 	4 	4 	48DJd333333	4 DIv{+++s$   "E3 32F('F($G: :1H.-H.c                    | j         S rq   )_isnanr   s    rs   rO   zDatetimeLikeArrayMixin.isna?  s
    {ru   c                "    | j         t          k    S )z-
        return if each value is nan
        )r   r   r   s    rs   rV  zDatetimeLikeArrayMixin._isnanB  s    
 yD  ru   c                N    t          | j                                                  S )zJ
        return if I have any nans; enables various perf speedups
        )r   rV  anyr   s    rs   _hasnazDatetimeLikeArrayMixin._hasnaI  s    
 DKOO%%&&&ru   r   c                    | j         r@|r|                    |          }|t          j        }t          j        || j        |           |S )az  
        Parameters
        ----------
        result : np.ndarray
        fill_value : object, default iNaT
        convert : str, dtype or None

        Returns
        -------
        result : ndarray with values replace by the fill_value

        mask the result if needed, convert to the provided dtype if its not
        None

        This is an internal routine.
        )rZ  r  r   nanputmaskrV  )r   r   
fill_valuer   s       rs   _maybe_mask_resultsz*DatetimeLikeArrayMixin._maybe_mask_resultsP  sO    & ; 	8 0w//!V
Jvt{J777ru   
str | Nonec                ,    | j         dS | j         j        S )a{  
        Return the frequency object as a string if it's set, otherwise None.

        Examples
        --------
        For DatetimeIndex:

        >>> idx = pd.DatetimeIndex(["1/1/2020 10:00:00+00:00"], freq="D")
        >>> idx.freqstr
        'D'

        The frequency can be inferred if there are more than 2 points:

        >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"],
        ...                        freq="infer")
        >>> idx.freqstr
        '2D'

        For PeriodIndex:

        >>> idx = pd.PeriodIndex(["2023-1", "2023-2", "2023-3"], freq="M")
        >>> idx.freqstr
        'M'
        N)r   freqstrr   s    rs   rb  zDatetimeLikeArrayMixin.freqstrn  s    4 94y  ru   c                h    | j         dk    rdS 	 t          j        |           S # t          $ r Y dS w xY w)ax  
        Tries to return a string representing a frequency generated by infer_freq.

        Returns None if it can't autodetect the frequency.

        Examples
        --------
        For DatetimeIndex:

        >>> idx = pd.DatetimeIndex(["2018-01-01", "2018-01-03", "2018-01-05"])
        >>> idx.inferred_freq
        '2D'

        For TimedeltaIndex:

        >>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"])
        >>> tdelta_idx
        TimedeltaIndex(['0 days', '10 days', '20 days'],
                       dtype='timedelta64[ns]', freq=None)
        >>> tdelta_idx.inferred_freq
        '10D'
        r   N)r   rf   
infer_freqr  r   s    rs   inferred_freqz$DatetimeLikeArrayMixin.inferred_freq  sL    0 9>>4	)$/// 	 	 	44	s   # 
11Resolution | Nonec                d    | j         }|d S 	 t          j        |          S # t          $ r Y d S w xY wrq   )rb  r   get_reso_from_freqstrKeyError)r   rb  s     rs   _resolution_objz&DatetimeLikeArrayMixin._resolution_obj  sK    ,?4	3G<<< 	 	 	44	s   ! 
//c                    | j         j        S )zO
        Returns day, hour, minute, second, millisecond or microsecond
        )rj  attrnamer   s    rs   
resolutionz!DatetimeLikeArrayMixin.resolution  s     #,,ru   c                D    t          j        | j        d          d         S )NTtimeliker   r   is_monotonicr   r   s    rs   _is_monotonic_increasingz/DatetimeLikeArrayMixin._is_monotonic_increasing      !$)d;;;A>>ru   c                D    t          j        | j        d          d         S )NTro  r   rq  r   s    rs   _is_monotonic_decreasingz/DatetimeLikeArrayMixin._is_monotonic_decreasing  rt  ru   c                |    t          t          | j                            d                              | j        k    S )NK)r   rV   r   r  sizer   s    rs   
_is_uniquez!DatetimeLikeArrayMixin._is_unique  s-    8DIOOC001122di??ru   c                   | j         dk    rbt          |dd           | j        k    rH ||                                 |                                                              | j                  S 	 |                     |          }n!# t          $ r t          | ||          cY S w xY wt          |dd           }t          |          rBt          j
        |t          j        |                     t                              |          }|S |t          u rQ|t           j        u r!t          j        | j        t&                    }n t          j        | j        t&                    }|S t+          | j        t.                    st1          t2          |           } | j        |j        k    rt+          |t7          |                     s]	 |                    | j        d          }n\# t<          $ r2 t          j        |j                   }tC          | j"        ||          cY S w xY w|j"        }tC          | j"        ||          S | #                    |          } || j"        $                    d          |$                    d                    }tK          |          }| j&        |z  }|'                                r$|t           j        u }	t          j(        |||	           |S )Nr   r  r}   r   Fr(  r{   ))r   r  r  r  r  r  r:   rd   rD   rS   comp_method_OBJECT_ARRAYr   r  r  r   r   operatorneonesr   rN  r|   r}   rK   r   TimelikeOpsr  r
  r,  r-  r  r^   asm8r%   r   r4  r~   rO   rV  rY  r]  )
r   r   rr   r}   r   	other_arr
other_valso_maskmask
nat_results
             rs   _cmp_methodz"DatetimeLikeArrayMixin._cmp_method  s   9q==WUGT::djHH2djjllEKKMM22::4:FFF	733E::EE  	7 	7 	7%dE266666	7 w--5!! 	 1BJt{{62233U F MC<<X[  4888$*D999M$*k22 	XT**D{el**!%d44 X %di% H H%   $&HUZ$8$8	= M9b       !&I9$-TVWWW[[''
DM&&t,,jood.C.CDDe{V#88:: 	1x{*JJvtZ000s$   /B B#"B#?G 9HH__pow____rpow____mul____rmul____truediv____rtruediv____floordiv____rfloordiv____mod____rmod__
__divmod____rdivmod__@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]c                    t          |t                    r
|j        }d}n4t          |t          t          f          r
|j        }d}n|j        }|j        }||fS )zN
        Get the int64 values and b_mask to pass to add_overflowsafe.
        N)r|   r   ordinalr   r   r   rV  r   )r   r   i8valuesr  s       rs   _get_i8_values_and_maskz.DatetimeLikeArrayMixin._get_i8_values_and_mask  sc     eV$$ 		"}HDD	9566 	"|HDD <DzH~ru   c                    t          | j        t                    r| j        S t	          j        |          sdS t          | j        t                    r| j        S dS )zP
        Check if we can preserve self.freq in addition or subtraction.
        N)r|   r}   rK   r   r   r   r   r   s     rs   _get_arithmetic_result_freqz2DatetimeLikeArrayMixin._get_arithmetic_result_freq(  sX     dj+.. 	9u%% 	4	4(( 	9tru   c                   t          j        | j        d          s9t          dt	          |           j         dt	          |          j                   t          d|           } ddlm} ddl	m
} |t          usJ t          |          rN| j        t          j                                        d| j         d	          z   } |j        ||j        
          S t%          |          }|                     |          \  } }t          d|           } |                     |          \  }}t+          | j        t/          j        |d
                    }|                    d| j         d	          } ||j        | j                  }|                    d| j         d	          }|                     |          }	 |j        |||	          S )Nr   cannot add  and rm   r   rk   )tz_to_dtypezM8[]r   r{   r   r-  r}   r   )r   is_np_dtyper}   r	  r
  r  r   pandas.core.arraysrk   pandas.core.arrays.datetimesr  r   rO   r   to_datetime64r  r-  _simple_newr   _ensure_matching_resosr  r   r   r   r  r~   r   r  )
r   r   rk   r  r   other_i8r  
res_valuesr}   new_freqs
             rs   _add_datetimelike_scalarz/DatetimeLikeArrayMixin._add_datetimelike_scalar8  s   tz3// 	Nd4jj1NNU8LNN   $d++444444<<<<<<C;; 	I ]S%6%8%8%?%?@Rdi@R@R@R%S%SSF,=,V6<HHHH%  11%88e$d++77>>&!$)RZ-M-M-MNN[[!3ty!3!3!344
uxdi888[[!3ty!3!3!344
33E::(}(5xPPPPru   c                    t          j        | j        d          s9t          dt	          |           j         dt	          |          j                   || z   S )Nr   r  r  )r   r  r}   r	  r
  r  r   s     rs   _add_datetime_arraylikez.DatetimeLikeArrayMixin._add_datetime_arraylikeZ  s[    tz3// 	Nd4jj1NNU8LNN  
 t|ru   datetime | np.datetime64c                4   | j         j        dk    r$t          dt          |           j                   t          d|           } t          |          r
| t          z
  S t          |          }| 	                    |          \  } }| 
                    |          S )Nr   "cannot subtract a datelike from a rk   )r}   r  r	  r
  r  r   rO   r   r   r  _sub_datetimelike)r   r   tss      rs   _sub_datetimelike_scalarz/DatetimeLikeArrayMixin._sub_datetimelike_scalard  s     :?c!!VdATVVWWWOT** ;; 	#:u..r22b%%b)))ru   c                B   | j         j        dk    r$t          dt          |           j                   t          |           t          |          k    rt          d          t          d|           } |                     |          \  } }| 	                    |          S )Nr   r  $cannot add indices of unequal lengthrk   )
r}   r  r	  r
  r  r   r  r   r  r  r   s     rs   _sub_datetime_arraylikez.DatetimeLikeArrayMixin._sub_datetime_arraylikew  s    :?c!!VdATVVWWWt99E

""CDDDOT**11%88e%%e,,,ru   Timestamp | DatetimeArrayc                2   t          d|           } ddlm} 	 |                     |           nN# t          $ rA}t          |                              dd          } t          |          |          |d }~ww xY w|                     |          \  }}t          | j
        t          j        | d                    }|                    d| j         d	          }|                     |          }	t          d
|	          }	 |j        ||j        |	          S )Nrk   r   rm   comparesubtractr{   r   timedelta64[r  zTick | Noner  )r   r  rm   _assert_tzawareness_compatr	  ro   replacer
  r  r   r   r   r  r~   r-  r  r  r}   )
r   r   rm   r  new_messager  r  r  res_m8r  s
             rs   r  z(DatetimeLikeArrayMixin._sub_datetimelike  s*   OT**555555	2++E2222 	2 	2 	2c((**9jAAK$s))K((c1	2  77>>&%diXIT1R1R1RSS
!<	!<!<!<==33E::x00)~)&8TTTTs   . 
A9<A44A9r   rl   c                   t          j        | j        d          s$t          dt	          |           j                   ddlm} t          j	        |j
        | j                  }t          |j                  } |||          }|| z   S )Nr   zcannot add Period to a r   )rl   r   )r   r  r}   r	  r
  r  pandas.core.arrays.periodrl   r   broadcast_tor  r  rK   r   )r   r   rl   i8valsr}   parrs         rs   _add_periodz"DatetimeLikeArrayMixin._add_period  s    tz3// 	MKd4jj6IKKLLL 	:99999
;;EJ''{6///d{ru   c                     t          |           rq   r   )r   offsets     rs   _add_offsetz"DatetimeLikeArrayMixin._add_offset  s    !$'''ru   c                   t          |          r{t          j        | j        d                              | j        j                  }|                    t                     t          |           
                    || j                  S t          d|           } t          |          }|                     |          \  } }|                     |          S )zk
        Add a delta of a timedeltalike

        Returns
        -------
        Same type as self
        r{   r   rM  )rO   r   emptyr  r~   r   r}   fillr   r
  r  r   r   r  _add_timedeltalike)r   r   
new_valuess      rs   _add_timedeltalike_scalarz0DatetimeLikeArrayMixin._add_timedeltalike_scalar  s     ;; 	H$*D999>>t}?RSSJOOD!!!::))*DJ)GGG 4d;;%  11%88e&&u---ru   c                    t          |           t          |          k    rt          d          t          d|           } |                     |          \  } }|                     |          S )zl
        Add a delta of a TimedeltaIndex

        Returns
        -------
        Same type as self
        r  rM  )r   r  r   r  r  r   s     rs   _add_timedelta_arraylikez/DatetimeLikeArrayMixin._add_timedelta_arraylike  se     t99E

""CDDD4d;;11%88e&&u---ru   Timedelta | TimedeltaArrayc                `   t          d|           } |                     |          \  }}t          | j        t	          j        |d                    }|                    | j        j                  }| 	                    |          }t          |                               || j        |          S )NrM  r{   r   r  )r   r  r   r   r   r  r~   r   r}   r  r
  r  )r   r   r  r  r  r  r  s          rs   r  z)DatetimeLikeArrayMixin._add_timedeltalike  s    4d;;77>>&%diHD1Q1Q1QRR
__T]%899
33E::
 Dzz%%djx & 
 
 	
ru   c                   t          | j        t                    r>t          dt	          |           j         dt	          t                    j                   t          d|           } t          j	        | j
        t          j                  }|                    t                     |                    | j        j                  }t	          |                               || j        d          S )z$
        Add pd.NaT to self
        zCannot add r  zTimedeltaArray | DatetimeArrayr   Nr  )r|   r}   rK   r	  r
  r  r   r   r   r  r  r  r  r   r~   r   r  r   r   s     rs   _add_natzDatetimeLikeArrayMixin._add_nat  s    
 dj+.. 	Ld4jj1LLS		8JLL   4d;; $*BH555DT]011 Dzz%%$*4 & 
 
 	
ru   c                "   t          j        | j        t           j                  }|                    t
                     | j        j        dv r.t          d|           } |	                    d| j
         d          S |	                    d          S )z+
        Subtract pd.NaT from self
        r   r   zDatetimeArray| TimedeltaArrayr  r  ztimedelta64[ns])r   r  r  r  r  r   r}   r  r   r~   r-  r  s     rs   _sub_natzDatetimeLikeArrayMixin._sub_nat  s     $*BH555D:?d""7>>D;;:di:::;;;;;0111ru   Period | PeriodArrayc                    t           j        t                    s9t          dt	          |          j         dt	                     j                   t          d                                 |                                |          \  }}t           j
        t          j        | d                    }t          j         fd|D                       }| j        }n
 j        |z  }t          ||<   |S )Ncannot subtract  from rl   r{   r   c                .    g | ]}j         j        |z  S r   )r   base)r   r   r   s     rs   
<listcomp>z:DatetimeLikeArrayMixin._sub_periodlike.<locals>.<listcomp>  s"    EEEATY^a/EEEru   )r|   r}   rK   r	  r
  r  r   r   r  r   r   r   r  r^   rV  r   )r   r   r  r  new_i8_datanew_datar  s   `      rs   _sub_periodlikez&DatetimeLikeArrayMixin._sub_periodlike
  s     $*k22 	T4;;#7TTtDzz?RTT   M4((##E***77>>&&ty"*hYd2S2S2STT8EEEEEEEFF>;DD ;'Dru   c                   |t           j        t           j        fv sJ t          |          dk    r| j        dk    r || |d                   S t          j        dt          |           j         dt          t                                 | j        |j        k    sJ | j        |j        f             ||                     d          t          j        |                    }|S )aZ  
        Add or subtract array-like of DateOffset objects

        Parameters
        ----------
        other : np.ndarray[object]
        op : {operator.add, operator.sub}

        Returns
        -------
        np.ndarray[object]
            Except in fastpath case with length 1 where we operate on the
            contained scalar.
        r   r   z)Adding/subtracting object-dtype array to z not vectorized.rK  O)r}  addsubr   r   rP  rQ  r
  r  r;   r?   r  r  r   r  )r   r   rr   r  s       rs   _addsub_object_arrayz+DatetimeLikeArrayMixin._addsub_object_array#  s      hlHL11111u::??tyA~~ 2dE!H%%%5Dzz"5 5 5'))		
 	
 	
 	
 zU[(((4:u{*C(((RC(("*U*;*;<<
ru   rG  namerH  c                  |dvr"t          d| dt          |                      t          t          |          } ||                                 fd|i|}t          |                               || j                  S )N>   cummaxcumminzAccumulation z not supported for rH  r   )r	  r
  r  rW   r   r  r}   )r   r  rH  r   rr   r   s         rs   _accumulatez"DatetimeLikeArrayMixin._accumulateG  s    +++QDQQT$ZZQQRRR/66DIIKK999&99Dzz%%fDJ%???ru   __add__c                   t          |dd           }t          |          }|t          u r|                                 }n{t	          |t
          t          t          j        f          r| 	                    |          }n=t	          |t                    r|                     |          }nt	          |t          t          j        f          r|                     |          }nt	          |t                    r1t!          j        | j        d          r|                     |          }nt!          j        |          rht	          | j        t*                    st-          |           t/          d|           }|                    ||j        j        z  t4          j                  }nt!          j        |d          r|                     |          }nt;          |          r!|                     |t4          j                  }nt!          j        |d          st	          |t>                    r|                      |          S tC          |          rgt	          | j        t*                    st-          |           t/          d|           }|                    ||j        j        z  t4          j                  }ntD          S t	          |t          j#                  r0t!          j        |j        d          rddl$m%}  |j&        |          S |S )Nr}   r   rl   r   r   r  )'r  r_   r   r  r|   r   r   r   rA  r  r   r  r   rB  r  r   r   r  r}   r  
is_integerrK   r'   r   _addsub_int_array_or_scalar_nr}  r  r  rD   r  rI   r  rB   NotImplementedndarrayr  rm   r.  r   r   other_dtyper   objrm   s         rs   r  zDatetimeLikeArrayMixin.__add__P  s   eWd33.u55 C<<]]__FFi@AA (	"33E::FFz** &	"%%e,,FF"-899 #	"22599FFv&& !	"3?4:s+K+K !	"%%e,,FF^E"" 	" dj+66 5.t444}d++C44USY\5I8<XXFF _[#.. 	"22599FF[)) 	"..uhlCCFF_[#.. 	"*3
 3
 	" //666k** 	"dj+66 5.t444}d++C44USY\5I8<XXFF "!fbj)) 	9coflC.P.P 	99999990>0888ru   c                ,    |                      |          S rq   )r  r   s     rs   __radd__zDatetimeLikeArrayMixin.__radd__  s    ||E"""ru   __sub__c                :   t          |dd           }t          |          }|t          u r|                                 }nt	          |t
          t          t          j        f          r| 	                    |           }nRt	          |t                    r|                     |           }n%t	          |t          t          j        f          r|                     |          }nt          j        |          rht	          | j        t$                    st'          |           t)          d|           }|                    ||j        j        z  t.          j                  }nqt	          |t2                    r|                     |          }nEt          j        |d          r|                     |           }nt;          |          r!|                     |t.          j                  }nt          j        |d          st	          |t>                    r|                      |          }nt	          |t$                    r|                     |          }n}tC          |          rgt	          | j        t$                    st'          |           t)          d|           }|                    ||j        j        z  t.          j                  }ntD          S t	          |t          j#                  r0t          j        |j        d          rddl$m%}  |j&        |          S |S )Nr}   rl   r   r   r   r  )'r  r_   r   r  r|   r   r   r   rA  r  r   r  r   rB  r  r   r  r}   rK   r'   r   r  r  r}  r  r   r  r  r  rD   r  rI   r  rB   r  r  r  rm   r.  r  s         rs   r  zDatetimeLikeArrayMixin.__sub__  s   eWd33.u55 C<<]]__FFi@AA (	"33UF;;FFz** &	"%%uf--FF"-899 #	"22599FF^E"" !	" dj+66 5.t444}d++C44USY\5I8<XXFFv&& 	"))%00FF _[#.. 	"22E6::FF[)) 	"..uhlCCFF_[#.. 	"*3
 3
 	" 11%88FF[11 
	"))%00FFk** 	"dj+66 5.t444}d++C44USY\5I8<XXFF "!fbj)) 	9coflC.P.P 	99999990>0888ru   c                4   t          |dd           }t          j        |d          pt          |t                    }|rpt          j        | j        d          rVt          j        |          rt          |          | z
  S t          |t                    sddl	m
}  |j        |          }|| z
  S | j        j        dk    rKt          |d          r;|s9t          dt          |           j         dt          |          j                   t          | j        t"                    rAt          j        |d          r,t          dt          |           j         d|j                   t          j        | j        d          rt%          d|           } |  |z   S | |z
   S )	Nr}   r   r   r   r  r  r  rm   )r  r   r  r|   rI   r}   r   r   r   r  rk   r.  r  r%  r	  r
  r  rK   r   )r   r   r  other_is_dt64rk   s        rs   __rsub__zDatetimeLikeArrayMixin.__rsub__  s   eWd33S99 
Z>
 >
  	#S_TZ== 	# }U## / ''$..e%;<< <<<<<<<44U;;4<Z_##w(?(?## T4::#6TTd5kk>RTT   
K00 	#S_[RU5V5V 	#WtDzz/BWW%+WWXXX_TZ-- 	#($//DEU?" ru   c                z    | |z   }|d d          | d d <   t          | j        t                    s|j        | _        | S rq   r|   r}   rK   r   r   r   r   r   s      rs   __iadd__zDatetimeLikeArrayMixin.__iadd__  B    )QQQ$*k22 	%DJru   c                z    | |z
  }|d d          | d d <   t          | j        t                    s|j        | _        | S rq   r   r  s      rs   __isub__zDatetimeLikeArrayMixin.__isub__  r  ru   qsnpt.NDArray[np.float64]interpolationc                J    t                                          ||          S )N)r  r  )r   	_quantile)r   r  r  r   s      rs   r
  z DatetimeLikeArrayMixin._quantile  s"     ww  Bm DDDru   axisrH  r  AxisInt | Nonec                   t          j        d|           t          j        || j                   t	          j        | j        ||          }|                     ||          S )a  
        Return the minimum value of the Array or minimum along
        an axis.

        See Also
        --------
        numpy.ndarray.min
        Index.min : Return the minimum value in an Index.
        Series.min : Return the minimum value in a Series.
        r   r  )nvvalidate_minvalidate_minmax_axisr   rR   nanminr   _wrap_reduction_resultr   r  rH  r   r   s        rs   minzDatetimeLikeArrayMixin.min  Y     	F###
di000t}4GGG**4888ru   c                   t          j        d|           t          j        || j                   t	          j        | j        ||          }|                     ||          S )a  
        Return the maximum value of the Array or maximum along
        an axis.

        See Also
        --------
        numpy.ndarray.max
        Index.max : Return the maximum value in an Index.
        Series.max : Return the maximum value in a Series.
        r   r  )r  validate_maxr  r   rR   nanmaxr   r  r  s        rs   maxzDatetimeLikeArrayMixin.max  r  ru   r   )rH  r  c               
   t          | j        t                    r%t          dt	          |           j         d          t          j        | j        ||| 	                                          }| 
                    ||          S )a  
        Return the mean value of the Array.

        Parameters
        ----------
        skipna : bool, default True
            Whether to ignore any NaT elements.
        axis : int, optional, default 0

        Returns
        -------
        scalar
            Timestamp or Timedelta.

        See Also
        --------
        numpy.ndarray.mean : Returns the average of array elements along a given axis.
        Series.mean : Return the mean value in a Series.

        Notes
        -----
        mean is only defined for Datetime and Timedelta dtypes, not for Period.

        Examples
        --------
        For :class:`pandas.DatetimeIndex`:

        >>> idx = pd.date_range('2001-01-01 00:00', periods=3)
        >>> idx
        DatetimeIndex(['2001-01-01', '2001-01-02', '2001-01-03'],
                      dtype='datetime64[ns]', freq='D')
        >>> idx.mean()
        Timestamp('2001-01-02 00:00:00')

        For :class:`pandas.TimedeltaIndex`:

        >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D')
        >>> tdelta_idx
        TimedeltaIndex(['1 days', '2 days', '3 days'],
                        dtype='timedelta64[ns]', freq=None)
        >>> tdelta_idx.mean()
        Timedelta('2 days 00:00:00')
        zmean is not implemented for zX since the meaning is ambiguous.  An alternative is obj.to_timestamp(how='start').mean()r  rH  r  )r|   r}   rK   r	  r
  r  rR   nanmeanr   rO   r  )r   rH  r  r   s       rs   meanzDatetimeLikeArrayMixin.mean'  s    X dj+.. 	7tDzz/B 7 7 7   MV$))++
 
 
 **4888ru   c                   t          j        d|           |'t          |          | j        k    rt	          d          t          j        | j        ||          }|                     ||          S )Nr   z abs(axis) must be less than ndimr  )	r  validate_medianabsr   r  rR   	nanmedianr   r  r  s        rs   medianzDatetimeLikeArrayMixin.median`  sk    
2v&&&D		TY 6 6?@@@!$-d6JJJ**4888ru   dropnac                    d }|r|                                  }t          j        |                     d          |          }|                    | j        j                  }t          t          j        |          }| 	                    |          S )Nr{   )r  )
rO   rP   moder~   r   r}   r   r   r  r   )r   r$  r  i8modesnpmodess        rs   _modezDatetimeLikeArrayMixin._modej  su     	99;;D/$))D//===,,t}233rz7++&&w///ru   howhas_dropped_na	min_countintngroupsidsnpt.NDArray[np.intp]c                  | j         }|j        dk    rK|dv rt          d| d          |dv r/t          j        d| d| dt
          t                      	           nwt          |t                    rK|dv rt          d
| d          |dv r/t          j        d| d| dt
          t                      	           n|dv rt          d| d          | j	        
                    d          }ddlm}	 |	                    |          }
 |	||
|          } |j        |f|||d d|}|j        |j        v r|S |j         dk    sJ |dv rvddlm} t          | j         t                    rt          d          t'          d|           } d| j         d}|
                    |          } |j        ||j                   S |
                    | j	        j                   }|                     |          S )Nr   )sumprodcumsumcumprodvarskewz!datetime64 type does not support z operations)rY  allr$  zh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z() instead.rK  zPeriod type does not support ze' with PeriodDtype is deprecated and will raise in a future version. Use (obj != pd.Period(0, freq)).)r3  r5  r7  r6  z"timedelta64 type does not support rz   r   )WrappedCythonOp)r*  r  r+  )r,  r.  comp_idsr  )stdsemr  z-'std' and 'sem' are not valid for PeriodDtyperM  zm8[r  r   )r}   r  r	  rP  rQ  rR  r?   r|   rK   r   r~   pandas.core.groupby.opsr9  get_kind_from_how_cython_op_ndim_compatr*  cast_blocklistr  rm   r   r-  r  r   )r   r*  r+  r,  r.  r/  r   r}   npvaluesr9  r  rr   r  rm   	new_dtypes                  rs   _groupby_opz"DatetimeLikeArrayMixin._groupby_opw  s    
:III TC T T TUUUn$$U U UDGU U U!/11	    {++ 	WIII P P P PQQQn$$X X XGJX X X!/11	    888 US U U UVVV =%%h//;;;;;;0055_4OOO.R.

 
 
 

 6R&&&  8++++.  999999$*k22 Q OPPP8$??D*di***I#33J->-j
@PQQQQ__T]%899
&&z222ru   rw   r   )NNF)r}   r   r   r   rw   r   )rw   r   )r   ro   rw   r   )r   r   rw   r   )r   r   rw   r   rw   r   )rw   rg   )rw   r   )r   r   rw   r   )F)r   r   rq   )r}   r   rw   r   )r   r2   rw   r   )r   r   rw   r3   )r   r0   rw   r   )rw   r   )r   r   r   r   rw   r   rw   r   T)r   r   rw   r3   )r}   r  rw   rk   )r}   r  rw   rm   ).)r}   r   rw   r(   )r  r   r  r   )r  r   rw   ro   )r  r   )rw   r6  )r   r(   rw   r>  )rw   r>  )r   r   rw   r   )rw   r`  )rw   rf  rw   ro   )rw   r  )rw   rk   )r   rk   rw   rk   )r   r  rw   rm   )r   rk   rw   rm   )r   r  rw   rm   )r   r   rw   rl   )r   rm   )r   r  )r   r  rw   r   )r   r   )r  ro   rH  r   rw   r3   )r  r  r  ro   rw   r3   )r  r  rH  r   )rH  r   r  r  )r$  r   )
r*  ro   r+  r   r,  r-  r.  r-  r/  r0  )`r  
__module____qualname____doc____annotations__r>   r   r   propertyr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r  r~   r  r"  r!  r  r5  r   r4  rZ   r=  rT   rO   rV  rZ  r   r_  rb  re  rj  rm  rs  rv  rz  r  rt   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  rc   r  r  r  r  r  r  r   r
  r  r  r  r#  r)  rC  __classcell__r   s   @rs   r   r      s	          $###4444))))   ^ IN( ( ( ( (
 ( ( ( X(( ( ( ((( ( ( (.( ( ( (,( ( (D D D D: : : : 
( 
( 
( X
(  (-$
( 
( 
( 
( 
( 
(            X    X     "   <! ! ! ! ! !,   
11 11 11 11 11 11 11f    X    X    X     X# # # # # # #" " "P  %;) ;) ;) ;) ;) ;)z    >8 8 8 8 8t" " " 
 
 
 U
" 	  	  	  \	 P, P, P, P,j    ! ! ! X! ' ' ' X' .24    < ! ! ! X!:    X<    X - - - X- ? ? ? X? ? ? ? X? @ @ @ X@5 5 5r ('	22G((44H''	22G((44H++M::K,,^<<L,,^<<L--o>>M''	22G((44H**<88J++M::K
   U$    U Q Q Q UQB    U * * * U*$ 
- 
- 
- U
- U U U UU& 
 
 
 U
( ( (. . .(. . . .$ 
 
 
 U
  
 
 U
, 2 2 U2&    U0 ! ! ! U!F 8< @ @ @ @ @ @ i((5 5 )(5n# # # i((5 5 )(5n     D       E E E E E E ,0 9 9 9 9 9 9" ,0 9 9 9 9 9 9" &*! 79 79 79 79 79 79r /3D 9 9 9 9 9 90 0 0 0 0M3 M3 M3 M3 M3 M3 M3 M3ru   r   c                  >    e Zd ZdZ ed          d
d            Zd	S )DatelikeOpszK
    Common ops for DatetimeIndex/PeriodIndex, but not TimedeltaIndex.
    zNhttps://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior)URLr   ro   rw   r   c                |    |                      |t          j                  }|                    t          d          S )a  
        Convert to Index using specified date_format.

        Return an Index of formatted strings specified by date_format, which
        supports the same string format as the python standard library. Details
        of the string format can be found in `python string format
        doc <%(URL)s>`__.

        Formats supported by the C `strftime` API but not by the python string format
        doc (such as `"%%R"`, `"%%r"`) are not officially supported and should be
        preferably replaced with their supported equivalents (such as `"%%H:%%M"`,
        `"%%I:%%M:%%S %%p"`).

        Note that `PeriodIndex` support additional directives, detailed in
        `Period.strftime`.

        Parameters
        ----------
        date_format : str
            Date format string (e.g. "%%Y-%%m-%%d").

        Returns
        -------
        ndarray[object]
            NumPy ndarray of formatted strings.

        See Also
        --------
        to_datetime : Convert the given argument to datetime.
        DatetimeIndex.normalize : Return DatetimeIndex with times to midnight.
        DatetimeIndex.round : Round the DatetimeIndex to the specified freq.
        DatetimeIndex.floor : Floor the DatetimeIndex to the specified freq.
        Timestamp.strftime : Format a single Timestamp.
        Period.strftime : Format a single Period.

        Examples
        --------
        >>> rng = pd.date_range(pd.Timestamp("2018-03-10 09:00"),
        ...                     periods=3, freq='s')
        >>> rng.strftime('%%B %%d, %%Y, %%r')
        Index(['March 10, 2018, 09:00:00 AM', 'March 10, 2018, 09:00:01 AM',
               'March 10, 2018, 09:00:02 AM'],
              dtype='object')
        )r   r   Fr   )r   r   r\  r  r   )r   r   r   s      rs   strftimezDatelikeOps.strftime  s5    b **{26*RR}}V%}000ru   N)r   ro   rw   r   )r  rJ  rK  rL  r=   rU  r   ru   rs   rR  rR    sW          \*  .1 .1 .1	 .1 .1 .1ru   rR  aO	  
    Perform {op} operation on the data to the specified `freq`.

    Parameters
    ----------
    freq : str or Offset
        The frequency level to {op} the index to. Must be a fixed
        frequency like 'S' (second) not 'ME' (month end). See
        :ref:`frequency aliases <timeseries.offset_aliases>` for
        a list of possible `freq` values.
    ambiguous : 'infer', bool-ndarray, 'NaT', default 'raise'
        Only relevant for DatetimeIndex:

        - 'infer' will attempt to infer fall dst-transition hours based on
          order
        - bool-ndarray where True signifies a DST time, False designates
          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.

    nonexistent : 'shift_forward', 'shift_backward', 'NaT', timedelta, default 'raise'
        A nonexistent time does not exist in a particular timezone
        where clocks moved forward due to DST.

        - 'shift_forward' will shift the nonexistent time forward to the
          closest existing time
        - 'shift_backward' will shift the nonexistent time backward to the
          closest existing time
        - 'NaT' will return NaT where there are nonexistent times
        - timedelta objects will shift nonexistent times by the timedelta
        - 'raise' will raise an NonExistentTimeError if there are
          nonexistent times.

    Returns
    -------
    DatetimeIndex, TimedeltaIndex, or Series
        Index of the same type for a DatetimeIndex or TimedeltaIndex,
        or a Series with the same index for a Series.

    Raises
    ------
    ValueError if the `freq` cannot be converted.

    Notes
    -----
    If the timestamps have a timezone, {op}ing will take place relative to the
    local ("wall") time and re-localized to the same timezone. When {op}ing
    near daylight savings time, use ``nonexistent`` and ``ambiguous`` to
    control the re-localization behavior.

    Examples
    --------
    **DatetimeIndex**

    >>> rng = pd.date_range('1/1/2018 11:59:00', periods=3, freq='min')
    >>> rng
    DatetimeIndex(['2018-01-01 11:59:00', '2018-01-01 12:00:00',
                   '2018-01-01 12:01:00'],
                  dtype='datetime64[ns]', freq='min')
    a  >>> rng.round('h')
    DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
                   '2018-01-01 12:00:00'],
                  dtype='datetime64[ns]', freq=None)

    **Series**

    >>> pd.Series(rng).dt.round("h")
    0   2018-01-01 12:00:00
    1   2018-01-01 12:00:00
    2   2018-01-01 12:00:00
    dtype: datetime64[ns]

    When rounding near a daylight savings time transition, use ``ambiguous`` or
    ``nonexistent`` to control how the timestamp should be re-localized.

    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

    >>> rng_tz.floor("2h", ambiguous=False)
    DatetimeIndex(['2021-10-31 02:00:00+01:00'],
                  dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

    >>> rng_tz.floor("2h", ambiguous=True)
    DatetimeIndex(['2021-10-31 02:00:00+02:00'],
                  dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
    a  >>> rng.floor('h')
    DatetimeIndex(['2018-01-01 11:00:00', '2018-01-01 12:00:00',
                   '2018-01-01 12:00:00'],
                  dtype='datetime64[ns]', freq=None)

    **Series**

    >>> pd.Series(rng).dt.floor("h")
    0   2018-01-01 11:00:00
    1   2018-01-01 12:00:00
    2   2018-01-01 12:00:00
    dtype: datetime64[ns]

    When rounding near a daylight savings time transition, use ``ambiguous`` or
    ``nonexistent`` to control how the timestamp should be re-localized.

    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 03:30:00"], tz="Europe/Amsterdam")

    >>> rng_tz.floor("2h", ambiguous=False)
    DatetimeIndex(['2021-10-31 02:00:00+01:00'],
                 dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

    >>> rng_tz.floor("2h", ambiguous=True)
    DatetimeIndex(['2021-10-31 02:00:00+02:00'],
                  dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
    a  >>> rng.ceil('h')
    DatetimeIndex(['2018-01-01 12:00:00', '2018-01-01 12:00:00',
                   '2018-01-01 13:00:00'],
                  dtype='datetime64[ns]', freq=None)

    **Series**

    >>> pd.Series(rng).dt.ceil("h")
    0   2018-01-01 12:00:00
    1   2018-01-01 12:00:00
    2   2018-01-01 13:00:00
    dtype: datetime64[ns]

    When rounding near a daylight savings time transition, use ``ambiguous`` or
    ``nonexistent`` to control how the timestamp should be re-localized.

    >>> rng_tz = pd.DatetimeIndex(["2021-10-31 01:30:00"], tz="Europe/Amsterdam")

    >>> rng_tz.ceil("h", ambiguous=False)
    DatetimeIndex(['2021-10-31 02:00:00+01:00'],
                  dtype='datetime64[ns, Europe/Amsterdam]', freq=None)

    >>> rng_tz.ceil("h", ambiguous=True)
    DatetimeIndex(['2021-10-31 02:00:00+02:00'],
                  dtype='datetime64[ns, Europe/Amsterdam]', freq=None)
    c                      e Zd ZU dZded<   dej        dfdLd
Zed             Z	e
d             Zej        dMd            ZedNd            ZeedOd                        ZedPd            ZedQd            ZedRd            ZdSdTdZd  ZdU fd$Zd% Z eeez                       d&'                    	 	 dVdWd-            Z eeez                       d.'                    	 	 dVdWd/            Z eeez                       d0'                    	 	 dVdWd1            Z ddd2dXd6Z!ddd2dXd7Z"dMd8Z#dYd9Z$dZ fd;Z%	 	 d[d\ fd>Z&e	 d]d^ fdC            Z'd_d` fdFZ(dadJZ)e
dbdK            Z* xZ+S )cr  zK
    Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
    znp.dtype_default_dtypeNFr   r   rw   r   c                P   t          j        t          |           j         dt          t                                 |t          |          }t          |d          }t          |t                    r|
                    dt                    }t          |dd           }|d u }|t          j        ur|nd }t          |t          |                     rp|rn7||j        }n-|r+|j        r$t!          |          }t#          ||j                  }|%||j        k    rt'          d| d	|j                   |j        }|j        }ns|qt          |t*          j                  r|j        j        d
v r|j        }nA| j        }t          |t*          j                  r |j        dk    r|                    |          }t          |t*          j                  s:t5          dt          |          j         dt          |           j         d          |j        dvrt5          d          |j        dk    r|"| j        }|                    | j                  }nnt          j        |d          r|                    |          }nCt          |t:                    r.| j        j        }| d|j         d}|                    |          }|                     ||          }|dk    r%t5          dt          |           j         d          |r|                                 }|rCt!          |          }|j        j        dk    r$t          |tB                    st'          d          tE          j#        | ||           || _$        |'|'t          |           %                    | |           d S d S d S )NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.rK  Tr*  r  na_valuer   dtype=z does not match data dtype Mmr{   zUnexpected type 'z'. 'values' must be a z6, ndarray, or Series or Index containing one of those.)r      z.Only 1-dimensional input arrays are supported.r   8[r  inferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.r   (TimedeltaArray/Index freq must be a Tick)r   r}   )&rP  rQ  r
  r  rR  r?   rF   r`   r|   r]   r;  r   r  r   
no_defaultr   r"   _validate_inferred_freqr}   r	  r   r   r  r  rW  r~   r  r   r  rI   r-  _validate_dtyper   r   r   r   r   _validate_frequency)	r   r   r}   r   r   re  explicit_noner  rB  s	            rs   r   zTimelikeOps.__init__  s    	Dzz" A A A'))	
 	
 	
 	
  ''EvT:::fl++ 	=__Wt_<<F663>11tttfd4jj)) 	0 B{ B&+ B .tV[AA Ufl%:%:MUMMv|MM   LE_FF]&"*-- 0&,2Ct2K2K+fbj11 0fld6J6J#[[//F&"*-- 	+DLL$9 + +::&+ + +  
 ;f$$MNNN<4 }+T%899-- 0U++E?33 0*/#44uz444	Y//$$VU337??,d4jj6I , , ,  
  	#[[]]F 	LT??D| C''
40F0F' JKKKtF%@@@@
 T%5JJ**466666 ! %5%5ru   c                     t          |           rq   r   )clsr   r}   s      rs   rc  zTimelikeOps._validate_dtype  s    !#&&&ru   c                    | j         S )zK
        Return the frequency object if it is set, otherwise None.
        r   r   s    rs   r   zTimelikeOps.freq  s    
 zru   c                    |st          |          }|                     | |           | j        j        dk    r$t	          |t
                    st          d          | j        dk    rt          d          || _	        d S )Nr   r`  r   zCannot set freq with ndim > 1)
r"   rd  r}   r  r|   r   r	  r   r  r   r   s     rs   r   zTimelikeOps.freq   s}    e$$E$$T5111z#%%j.E.E% JKKKy1}} !@AAA


ru   validate_kwdsdictc                N   |	d| _         dS |dk    r$| j         t          | j                  | _         dS dS |t          j        u rdS | j         4t          |          } t          |           j        | |fi | || _         dS t          |          }t          || j                    dS )z
        Constructor helper to pin the appropriate `freq` attribute.  Assumes
        that self._freq is currently set to any freq inferred in
        _from_sequence_not_strict.
        Nr_  )r   r"   re  r   ra  r
  rd  rb  )r   r   rk  s      rs   _maybe_pin_freqzTimelikeOps._maybe_pin_freq  s     <DJJJW__ z! 't'9::


 "! S^## DZ T??D*DJJ*4GGGGGDJJJ T??D#D$*55555ru   r   r   c           	     h   |j         }|j        dk    s||j        k    rdS 	  | j        d|d         dt	          |          ||j        d|}t          j        |j        |j                  st          dS # t          $ r3}dt          |          v r|t          d| d|j                   |d}~ww xY w)am  
        Validate that a frequency is compatible with the values of a given
        Datetime Array/Index or Timedelta Array/Index

        Parameters
        ----------
        index : DatetimeIndex or TimedeltaIndex
            The index on which to determine if the given frequency is valid
        freq : DateOffset
            The frequency to validate
        r   N)startendperiodsr   r-  z	non-fixedInferred frequency 9 from passed values does not conform to passed frequency r   )re  ry  rb  _generate_ranger   r-  r   array_equalr   r  ro   )rg  indexr   r   rT  on_freqr  s          rs   rd  zTimelikeOps._validate_frequency.  s    &:??h$,664	)c) AhE

Z   G >%*gl;; !  ! ! 	 	 	c#hh&& 	 Gh G G8<G G  	s   AA4 4
B1>.B,,B1rr  
int | Noner3   c                     t          |           rq   r   )rg  rp  rq  rr  r   r   r   s          rs   ru  zTimelikeOps._generate_rangeZ  s     "#&&&ru   r-  c                4    t          | j        j                  S rq   )r   r   r}   r   s    rs   r  zTimelikeOps._cresob  s    "4=#6777ru   ro   c                *    t          | j                  S rq   )dtype_to_unitr}   r   s    rs   r-  zTimelikeOps.unitf  s    
 TZ(((ru   Tr-  r)  c                   |dvrt          d          t          j        | j        j         d| d          }t	          | j        ||          }t          | j        t          j                  r|j        }n&t          d|           j        }t          ||          }t          |                               ||| j                  S )	N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'r^  r  r(  rk   r  r  )r  r   r}   r  r   r   r|   r   r   rI   r
  r  r   )r   r-  r)  r}   r  rB  r   s          rs   r,  zTimelikeOps.as_unitm  s    ...HIIIDJO66t66677(QQQ
dj"(++ 	:"(IIot,,/B'2D999I Dzz%%idi & 
 
 	
ru   c                    | j         |j         k    rE| j         |j         k     r|                     |j                  } n|                    | j                  }| |fS rq   )r  r,  r-  r   s     rs   r  z"TimelikeOps._ensure_matching_resos  sR    ;%,&&{U\))||EJ//di00U{ru   ufuncnp.ufuncmethodc                    |t           j        t           j        t           j        fv r9t	          |          dk    r&|d         | u r t          ||          | j        fi |S  t                      j        ||g|R i |S )Nr   r   )	r   isnanisinfisfiniter   r  r   r   __array_ufunc__)r   r  r  inputsr   r   s        rs   r  zTimelikeOps.__array_ufunc__  s    bh"+666Fq  q	T!! *75&))$-BB6BBB&uww&ufHvHHHHHHru   c                v   t          | j        t                    rZt          d|           } |                     d           }|                    ||||          }|                    | j        ||          S |                     d          }t          t          j	        |          }t          || j                  }|dk    r|                                 S t          |||          }	|                     |	t                    }|                    | j        j                  }|                     || j                  S )Nrk   )	ambiguousnonexistentr{   r   r^  r   )r|   r}   rI   r   tz_localize_roundr   r~   r   r  r&   r  r   r$   r_  r   r   r  )
r   r   r&  r  r  naiver   r   nanos	result_i8s
             rs   r  zTimelikeOps._round  s   dj/22 	..D$$T**E\\$iEEF%%9+ &    4bj&))"455A::99;;!&$66	))))EET]011dj999ru   round)rr   raiser  r5   r  r6   c                F    |                      |t          j        ||          S rq   )r  r#   NEAREST_HALF_EVENr   r   r  r  s       rs   r  zTimelikeOps.round  s     {{4!:I{SSSru   floorc                F    |                      |t          j        ||          S rq   )r  r#   MINUS_INFTYr  s       rs   r  zTimelikeOps.floor  s     {{4!4iMMMru   ceilc                F    |                      |t          j        ||          S rq   )r  r#   
PLUS_INFTYr  s       rs   r  zTimelikeOps.ceil  s     {{4!3YLLLru   r  r  r  rH  c               `    t          j        | j        |||                                           S Nr  )rR   nananyr   rO   r   r  rH  s      rs   rY  zTimelikeOps.any  s%    }T]f499;;WWWWru   c               `    t          j        | j        |||                                           S r  )rR   nanallr   rO   r  s      rs   r8  zTimelikeOps.all  s'     }T]f499;;WWWWru   c                    d | _         d S rq   ri  r   s    rs   r   zTimelikeOps._maybe_clear_freq  s    


ru   c                4   |nyt          |           dk    rJt          |t                    r5| j        j        dk    r$t          |t
                    st          d          n|dk    sJ t          | j                  }| 	                                }||_
        |S )z
        Helper to get a view on the same data, with a new freq.

        Parameters
        ----------
        freq : DateOffset, None, or "infer"

        Returns
        -------
        Same type as self
        Nr   r   r`  r_  )r   r|   r   r}   r  r   r	  r"   re  r~   r   )r   r   r   s      rs   
_with_freqzTimelikeOps._with_freq  s     <YY!^^
4 < <^z#%%jt.D.D% JKKK 7????T/00Diikk	
ru   r   c                    t          | j        t          j                  r| j        S t	                                                      S rq   )r|   r}   r   r   r   _values_for_json)r   r   s    rs   r  zTimelikeOps._values_for_json  s7    dj"(++ 	!= ww'')))ru   use_na_sentinelsortc                ~   | j         mt          j        t          |           t          j                  }|                                 }|r&| j         j        dk     r|d d d         }|d d d         }||fS |r%t          dt          |           j	         d          t                                          |          S )Nr   r   zThe 'sort' keyword in zu.factorize is ignored unless arr.freq is not None. To factorize with sort, call pd.factorize(obj, sort=True) instead.)r  )r   r   aranger   intpr   r   NotImplementedErrorr
  r  r   	factorize)r   r  r  codesuniquesr   s        rs   r  zTimelikeOps.factorize	  s    
 9 Ic$iirw777EiikkG (	addd!$$B$-'>! 	 &=d)< = = =  
 ww   AAAru   r   	to_concatSequence[Self]r)   c                X   t                                          ||          }|d         |dk    rwd |D             }j        dt          fd|D                       rIt	          |d d         |dd                    }t          fd|D                       rj        }||_        |S )Nr   c                0    g | ]}t          |          |S r   )r   )r   r   s     rs   r  z1TimelikeOps._concat_same_type.<locals>.<listcomp>&	  s#    888qQ8888ru   c              3  8   K   | ]}|j         j         k    V  d S rq   r   )r   r   r  s     rs   r   z0TimelikeOps._concat_same_type.<locals>.<genexpr>(	  s,      +R+R1AFch,>+R+R+R+R+R+Rru   r  r   c              3  d   K   | ]*}|d          d         j         z   |d         d          k    V  +dS )r   r  r   Nr  )r   pairr  s     rs   r   z0TimelikeOps._concat_same_type.<locals>.<genexpr>*	  s?      NNtAwr{SX-a;NNNNNNru   )r   _concat_same_typer   r8  zipr   )rg  r  r  new_objpairsr  r  r   s         @rs   r  zTimelikeOps._concat_same_type	  s     ''++It<<l199 98I888Ix#+R+R+R+R	+R+R+R(R(R#IcrcNIabbM::NNNNNNNNN -"xH$,GMru   Corderc                d    t                                          |          }| j        |_        |S )N)r  )r   r   r   r   )r   r  r  r   s      rs   r   zTimelikeOps.copy/	  s(    '',,U,++	ru   r.   rw  rj   c          
         |dk    rt           |s| j        }	n| j                                        }	t          j        |	f||||||d| |s| S t          |                               |	| j                  S )z2
        See NDFrame.interpolate.__doc__.
        linear)r  r  rw  limitlimit_direction
limit_arear   )r  r   r   rQ   interpolate_2d_inplacer
  r  r}   )
r   r  r  rw  r  r  r  r   r   out_datas
             rs   interpolatezTimelikeOps.interpolate4	  s      X%% 	,}HH}))++H&		
+!		
 		
 		
 		
 		
  	KDzz%%hdj%AAAru   c                
   t          j        | j                  sdS | j        }|t          k    }t          | j                  }t          |          }t          j        |||z  dk              	                                dk    }|S )z
        Check if we are round times at midnight (and no timezone), which will
        be given a more compact __repr__ than other cases. For TimedeltaArray
        we are checking for multiples of 24H.
        Fr   )
r   r  r}   r   r   r   r!   r   logical_andr2  )r   
values_intconsider_valuesr   ppd	even_dayss         rs   _is_dates_onlyzTimelikeOps._is_dates_only]	  s     tz** 	5Y
$,"4:..d## N?J4D4IJJNNPPTUU	ru   )r   r   rw   r   rF  )rk  rl  )r   r   )rr  ry  rw   r3   )rw   r-  rI  rG  )r-  ro   r)  r   rw   r3   )r  r  r  ro   )r  r  )r  r5   r  r6   rw   r3   )r  r  rH  r   rw   r   rH  rE  )TF)r  r   r  r   )r   )r  r  r  r)   rw   r3   )r  )r  ro   rw   r3   )
r  r.   r  r-  rw  rj   r   r   rw   r3   rD  ),r  rJ  rK  rL  rM  r   ra  r   classmethodrc  rN  r   setterr   rn  rd  ru  r>   r  r-  r,  r  r  r  r<   
_round_doc_round_exampler   r  _floor_exampler  _ceil_exampler  rY  r8  r   r  r  r  r  r   r  r  rO  rP  s   @rs   r  r    s           !s~EZ7 Z7 Z7 Z7 Z7x ' ' ['   X 
[
 
 
 [
 6 6 6 U6@ ( ( ( [ U(T ' ' ' [' 8 8 8 ^8 ) ) ) ^)
 
 
 
 
*  	I 	I 	I 	I 	I 	I: : :, XzN*22g2>>?? $+'.	T T T T @?T XzN*22g2>>?? $+'.	N N N N @?N XzM)11V1<<== $+'.	M M M M >=M -1 X X X X X X -1 X X X X X X      @* * * * * * !%B B B B B B B0        [*      
$B $B $B $BR    X    ru   r  r   r   cls_nametuple[ArrayLike, bool]c                d   t          | d          sUt          | t          t          f          s't	          j        |           dk    rt          |           } t          |           } d}n9t          | t                    rt          d| d          t          | d          } t          | t                    s#t          | t                    r-| j        j        dv r|                     d	t          
          } d}nt          | t                    r+|                                 } |                                 } d}nxt          | t          j        t$          f          st	          j        |           } nBt          | t(                    r-| j                            | j        t0                    j        } d}| |fS )Nr}   r   FzCannot create a z from a MultiIndex.Tr*  r   r  rY  r  )r%  r|   r   tupler   r   r@   rM   r	  r`   r]   r[   r}   r  r;  r   _maybe_convert_datelike_arrayr  r\   r  rL   r1  taker  r   _values)r   r   r  s      rs   !ensure_arraylike_for_datetimeliker  w	  s    4!! 7$u.. 	274==A3E3E::D6t<<	D-	(	( 7H8HHHIIIT666$%% 4,--26*/T2I2I}}Wt}44	D-	.	. 1133}}rz>:;; 	z$	D.	)	)  ##DJ3#??G:ru   rr  r   c                    d S rq   r   rr  s    rs   validate_periodsr  	      Cru   int | floatr-  c                    d S rq   r   r  s    rs   r  r  	  r  ru   int | float | Nonery  c                    | rt          j        |           r8t          j        dt          t                                 t          |           } n&t          j        |           st          d|            | S )a9  
    If a `periods` argument is passed to the Datetime/Timedelta Array/Index
    constructor, cast it to an integer.

    Parameters
    ----------
    periods : None, float, int

    Returns
    -------
    periods : None or int

    Raises
    ------
    TypeError
        if periods is None, float, or int
    NzNon-integer 'periods' in pd.date_range, pd.timedelta_range, pd.period_range, and pd.interval_range are deprecated and will raise in a future version.rK  zperiods must be a number, got )	r   is_floatrP  rQ  rR  r?   r-  r  r	  r  s    rs   r  r  	  s    $ <   	HM2 +--    'llGG(( 	HFWFFGGGNru   r   r   re  c                V    |&|  | |k    rt          d| d| j                   | |} | S )a
  
    If the user passes a freq and another freq is inferred from passed data,
    require that they match.

    Parameters
    ----------
    freq : DateOffset or None
    inferred_freq : DateOffset or None

    Returns
    -------
    freq : DateOffset or None
    Nrs  rt  )r  rb  )r   re  s     rs   rb  rb  	  s]        5 5"m " "<" "  
 < DKru   r}   'DatetimeTZDtype | np.dtype | ArrowDtypec                    t          | t                    r| j        S t          | t                    r(| j        dvrt          d| d          | j        j        S t          j        |           d         S )z
    Return the unit str corresponding to the dtype's resolution.

    Parameters
    ----------
    dtype : DatetimeTZDtype or np.dtype
        If np.dtype, we assume it is a datetime64 dtype.

    Returns
    -------
    str
    r   r[  z does not have a resolution.r   )	r|   rI   r-  rG   r  r  pyarrow_dtyper   datetime_datar   s    rs   r}  r}  	  sy     %)) (z	E:	&	& (:T!!DDDDEEE"''E""1%%ru   )rn   ro   )rv   r-   rw   r-   )r   r   r  ro   rw   r  )rr  r   rw   r   )rr  r  rw   r-  )rr  r  rw   ry  )r   r   re  r   rw   r   )r}   r  rw   ro   )
__future__r   r   r   	functoolsr   r}  typingr   r   r	   r
   r   r   r   r   rP  numpyr   pandas._libsr   r   pandas._libs.arraysr   pandas._libs.tslibsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   r"   pandas._libs.tslibs.fieldsr#   r$   pandas._libs.tslibs.np_datetimer%   pandas._libs.tslibs.timedeltasr&   pandas._libs.tslibs.timestampsr'   pandas._typingr(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   pandas.compat.numpyr8   r  pandas.errorsr9   r:   r;   pandas.util._decoratorsr<   r=   r>   pandas.util._exceptionsr?   pandas.core.dtypes.castr@   pandas.core.dtypes.commonrA   rB   rC   rD   rE   rF   pandas.core.dtypes.dtypesrG   rH   rI   rJ   rK   pandas.core.dtypes.genericrL   rM   pandas.core.dtypes.missingrN   rO   pandas.corerP   rQ   rR   rS   pandas.core.algorithmsrT   rU   rV   pandas.core.array_algosrW   pandas.core.arraylikerX   pandas.core.arrays._mixinsrY   rZ   pandas.core.arrays.arrow.arrayr[   pandas.core.arrays.baser\   pandas.core.arrays.integerr]   pandas.core.commoncorecommonr   pandas.core.constructionr^   r0  r_   r`   pandas.core.indexersra   rb   pandas.core.ops.commonrc   pandas.core.ops.invalidrd   re   pandas.tseriesrf   collections.abcrg   rh   r:  rj   r  rk   rl   rm   r   rt   r   r   rR  r  r  r  r  r  r  r  rb  r}  r   ru   rs   <module>r     s#   " " " " " "              	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	             . - - - - -                                     &        K J J J J J = = = = = = C C C C C C                                   $ / . . . . .         
         
 5 4 4 4 4 4 K K K K K K                                          
                    
 ? > > > > > * * * * * *        ? > > > > > 2 2 2 2 2 2 3 3 3 3 3 3                           
        < ; ; ; ; ;       
 ' & & & & &        
           ('121 1 1 1
   6@3 @3 @3 @3 @3)@3 @3 @3F071 71 71 71 71( 71 71 71t=
~668^ ^ ^ ^ ^( ^ ^ ^J$ $ $ $N 
   
 
   
   D   :& & & & & &ru   