a
    Of\                    @  s  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}  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 Zd'd(d)d*Zd+d+d,d-d.ZG d/d0 d0eretZG d1d2 d2eZd3Zd4Zd5Zd6ZG d7d8 d8eZd9d'd:d;d<d=Zed>d>d?d@dAZedBdCd?dDdAZdEdFd?dGdAZdHdHdHdIdJdKZdLd'dMdNdOZdS )P    )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str)op_namec                 C  s   t | }t| |S N)rd   rb   )rn   op rq   X/var/www/ai-form-bot/venv/lib/python3.9/site-packages/pandas/core/arrays/datetimelike.py_make_unpacked_invalid_op   s    rs   r,   )methreturnc                   s   t   fd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                   sx   t | jts" | g|R i |S | d} |g|R i |}|tu rNtS t |trd| |jS |d}| |S )NM8[ns]i8)	
isinstancedtyperJ   viewr   r   	_box_func_value_from_backing_data)selfargskwargsarrresultZres_i8rt   rq   rr   new_meth   s    


z"_period_dispatch.<locals>.new_meth)r   r   r,   )rt   r   rq   r   rr   _period_dispatch   s    r   c                      s  e Zd ZU dZded< ded< ded< ded	< d
ed< eddddZdddddddZeddddZ	dddddZ
dddd d!Zddd"d#d$Zd%d& Zddd'd(Zd)dd*d+Zed,dd-d.Zd/dd0d1d2d3d4d5Zddd6d7d8Zdd9d:ddd;d<Zed=dd>d?d@ZedAdBd>dCd@ZdDdEdF fdGd@Zd
ddHdIZdJdKddL fdMdNZdddOdPZdddR fdSdTZedBddUdVZedWdXdYdZdVZed[d\dYd]dVZeddd_dYd`dVZddd_dY fdadVZdbdc ZddQdddddddedfZddddgdhdiZdddjdkdlZdmdn Ze doddpdqZ!e"ddrdsZ#d_dtdudvdwZ$dtddxdyZ%edtddzd{Z&eddd|d}Z'e(dfddd~ddZ)eddddZ*eddddZ+eddddZ,eddddZ-eddddZ.eddddZ/eddddZ0dd Z1e2dZ3e2dZ4e2dZ5e2dZ6e2dZ7e2dZ8e2dZ9e2dZ:e2dZ;e2dZ<e2dZ=e2dZ>e ddddZ?e d
dddZ@e dXdddZAe dXdXd"ddZBe dd\d"ddZCe dXd\d"ddZDe dd\d"ddZEe ddd"ddZFdd ZGdd ZHd\dddZIe ddddZJe dd ZKe dd ZLe dd2d"ddĄZMe d2dddƄZNdQdǜdddBdȜddʄZOePd˃dd̈́ ZQddτ ZRePdЃdd҄ ZSddԄ ZTdBdddքZUdBddd؄ZVeWdddBdڜ fdd܄ZXeWddQdݜdddݜddZYeWddQdݜdddݜddZZdQdddddddZ[eWddQdݜdddݜddZ\dddddZ]ddddddddZ^  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freqboolru   c                 C  s   dS )NTrq   r~   rq   rq   rr   _can_hold_na   s    z#DatetimeLikeArrayMixin._can_hold_naNFzDtype | NoneNone)ry   copyru   c                 C  s   t | d S ro   r8   )r~   datary   r   r   rq   rq   rr   __init__   s    zDatetimeLikeArrayMixin.__init__ztype[DatetimeLikeScalar]c                 C  s   t | dS )z
        The scalar associated with this datelike

        * PeriodArray : Period
        * DatetimeArray : Timestamp
        * TimedeltaArray : Timedelta
        Nr   r   rq   rq   rr   _scalar_type   s    	z#DatetimeLikeArrayMixin._scalar_typerm   DTScalarOrNaT)valueru   c                 C  s   t | dS )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.
        Nr   r~   r   rq   rq   rr   _scalar_from_string   s    z*DatetimeLikeArrayMixin._scalar_from_stringz)np.int64 | np.datetime64 | np.timedelta64c                 C  s   t | dS )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')
        Nr   r   rq   rq   rr   _unbox_scalar   s    z$DatetimeLikeArrayMixin._unbox_scalar)otherru   c                 C  s   t | dS )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
        Nr   r~   r   rq   rq   rr   _check_compatible_with  s    z-DatetimeLikeArrayMixin._check_compatible_withc                 C  s   t | dS )zI
        box function to get object from internal representation
        Nr   )r~   xrq   rq   rr   r{   -  s    z DatetimeLikeArrayMixin._box_funcc                 C  s   t j|| jddS )z1
        apply box func to passed values
        F)convert)r   Z	map_inferr{   )r~   valuesrq   rq   rr   _box_values3  s    z"DatetimeLikeArrayMixin._box_valuesrf   c                   s<    j dkr$ fddtt D S  fdd jD S d S )N   c                 3  s   | ]} | V  qd S ro   rq   ).0nr   rq   rr   	<genexpr>;      z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>c                 3  s   | ]}  |V  qd S ro   )r{   )r   vr   rq   rr   r   =  r   )ndimrangelenasi8r   rq   r   rr   __iter__9  s    
zDatetimeLikeArrayMixin.__iter__znpt.NDArray[np.int64]c                 C  s   | j dS )z
        Integer representation of the values.

        Returns
        -------
        ndarray
            An ndarray with int64 dtype.
        rw   )r   rz   r   rq   rq   rr   r   ?  s    zDatetimeLikeArrayMixin.asi8r   )na_repdate_formatzstr | floatnpt.NDArray[np.object_])r   ru   c                C  s   t | dS )z|
        Helper method for astype when converting to strings.

        Returns
        -------
        ndarray[str]
        Nr   )r~   r   r   rq   rq   rr   _format_native_typesO  s    
z+DatetimeLikeArrayMixin._format_native_types)boxedc                 C  s   dj S )Nz'{}')format)r~   r   rq   rq   rr   
_formatter[  s    z!DatetimeLikeArrayMixin._formatterzNpDtype | Nonezbool | Nonec                 C  s    t |rtjt| tdS | jS )Nry   )rC   npr]   listobjectr   )r~   ry   r   rq   rq   rr   	__array__b  s    z DatetimeLikeArrayMixin.__array__r1   )itemru   c                 C  s   d S ro   rq   r~   r   rq   rq   rr   __getitem__j  s    z"DatetimeLikeArrayMixin.__getitem__z(SequenceIndexer | PositionalIndexerTupler2   c                 C  s   d S ro   rq   r   rq   rq   rr   r   n  s    r/   zSelf | DTScalarOrNaT)keyru   c                   s:   t dt |}t|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_scalarr2   _get_getitem_freq_freq)r~   r   r   	__class__rq   rr   r   u  s    

c                 C  s   t | jt}|r| j}n| jdkr(d}nt| |}d}t |trj| jdurb|jdurb|j| j }q| j}n@|tu rz| j}n0t	
|rt|tj}t |tr| |S |S )z\
        Find the `freq` attribute to assign to the result of a __getitem__ lookup.
        r   N)rx   ry   rJ   r   r   r`   slicestepEllipsiscomZis_bool_indexerr   Zmaybe_booleans_to_slicerz   r   Zuint8r   )r~   r   Z	is_periodr   Znew_keyrq   rq   rr   r     s$    





z(DatetimeLikeArrayMixin._get_getitem_freqz,int | Sequence[int] | Sequence[bool] | slicezNaTType | Any | Sequence[Any])r   r   ru   c                   s.   t ||| }t || |r"d S |   d S ro   )ra   r   __setitem___maybe_clear_freq)r~   r   r   Zno_opr   rq   rr   r     s
    z"DatetimeLikeArrayMixin.__setitem__c                 C  s   d S ro   rq   r   rq   rq   rr   r     s    z(DatetimeLikeArrayMixin._maybe_clear_freqTr   c                   s8  t |}|tkrv| jjdkrDtd| } | j}t|| jd| jd}|S | jjdkr^t	| j
ddS | | j | jS t|trt j||dS t|r|  S |jd	v r| j}|tjkrtd
| j d| d|r| }|S |jdv  r| j|ks|jdkr&dt| j d| }t|ntj| |dS d S )NMrj   	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   )rE   r   ry   kindr   r   r   r   _cresor   r   r   ravelreshapeshaperx   rI   r   astyperD   r   r   int64	TypeErrorr   type__name__asarray)r~   ry   r   Zi8dataZ	convertedr   msgr   rq   rr   r     s@    



$
zDatetimeLikeArrayMixin.astypec                 C  s   d S ro   rq   r   rq   rq   rr   rz     s    zDatetimeLikeArrayMixin.viewzLiteral['M8[ns]']rj   ry   ru   c                 C  s   d S ro   rq   r~   ry   rq   rq   rr   rz     s    zLiteral['m8[ns]']rl   c                 C  s   d S ro   rq   r   rq   rq   rr   rz     s    .r'   c                 C  s   d S ro   rq   r   rq   rq   rr   rz     s    c                   s   t  |S ro   )r   rz   r   r   rq   rr   rz     s    c              
   C  s0  t |tr8z| |}W n ttfy6   t|Y n0 t || jsL|tu r| |}z| 	| W n2 t
tfy } zt||W Y d }~n
d }~0 0 nt|st|nt|t| krtdnfz| j|dd}| 	| W nH t
tfy* } z*tt|dd rn
t||W Y d }~n
d }~0 0 |S )NzLengths must matchTallow_objectry   )rx   rm   r   
ValueErrorr   r9   r   r   r   r   r   rB   r   _validate_listlikerC   getattr)r~   r   errrq   rq   rr   _validate_comparison_value  s.    

"

 z1DatetimeLikeArrayMixin._validate_comparison_value)allow_listlikeunboxc             
   C  s   t || jrnt |trdz| |}W q ty` } z"| ||}t||W Y d}~qd}~0 0 n\t|| jrvt	}nJt
|r| ||}t|n,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)rx   r   rm   r   r   _validation_error_messager   rM   ry   r   rN   r   r   )r~   r   r   r   r   r   rq   rq   rr   _validate_scalar0  s(    
"
z'DatetimeLikeArrayMixin._validate_scalar)r   ru   c                 C  sp   t |dr(t|dddkr(|j d}ndt|j d}|rVd| 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
        ry   r   r   z array'zvalue should be a 'z!', 'NaT', or array of those. Got z	 instead.z' or 'NaT'. Got )hasattrr   ry   r   r   r   )r~   r   r   Zmsg_gotr   rq   rq   rr   r   m  s    z0DatetimeLikeArrayMixin._validation_error_messager   c              	   C  s  t |t| r2| jjdv r.|s.|j| jdd}|S t |tr\t|dkr\t| jg | jdS t	|dr|jt
krt|| jv rzt| |}W n6 ttfy   |r| Y S | |d}t|Y n0 t|dd}t|}t|dd}t|r"zt| j|| jd}W n ty    Y n0 t |jtrT|jj| jkrT| }t|dd}|rht|jrhn&t| |js| |d}t|| jjdv r|s|j| jdd}|S )	Nr   Fround_okr   r   ry   TZextract_numpy)rx   r   ry   r   as_unitunitr   r   _from_sequencer   r   r   infer_dtyper   r   r   r   r_   pd_arrayr@   rG   
categoriesZ_internal_get_valuesrC   r   )r~   r   r   r   rq   rq   rr   r     sF    
z)DatetimeLikeArrayMixin._validate_listlikec                 C  s,   t |r| |}n| j|ddS | |S )NT)r   )rB   r   r   _unboxr   rq   rq   rr   _validate_setitem_value  s    z.DatetimeLikeArrayMixin._validate_setitem_valuez6np.int64 | np.datetime64 | np.timedelta64 | np.ndarrayc                 C  s*   t |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   rq   rq   rr   r     s
    

zDatetimeLikeArrayMixin._unboxc                 C  s>   ddl m} t| ||d}||}t|tr4| S |jS d S )Nr   rh   )	na_action)pandasri   rT   rx   rL   to_numpyr]   )r~   Zmapperr   ri   r   rq   rq   rr   map  s    
zDatetimeLikeArrayMixin.mapznpt.NDArray[np.bool_])r   ru   c              	   C  sp  |j jdv rtj| jtdS t|}t|t| sg d}|j t	krt
j|d| j d}|j t	krl| |S t
j|dd}||vr|dkrn(d	|v rt| t	|S tj| jtdS zt| |}W n" ty   t| t	| Y S 0 tjd
| j  dtt d | j jdv r*td| } || j}z| | W n( ttfy`   tj| jtd Y S 0 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]
        Zfiucr   )r   timedelta64r   
datetime64dateZperiodT)Zconvert_non_numericZ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)ry   r   r   zerosr   r   r^   rx   r   r   r   Zmaybe_convert_objectsrS   r   r   r   r   warningswarnFutureWarningr>   r   r   r   r   r   r   )r~   r   Z	inferableinferredrq   rq   rr   rS     sJ    



zDatetimeLikeArrayMixin.isinc                 C  s   | j S ro   )_isnanr   rq   rq   rr   rN   A  s    zDatetimeLikeArrayMixin.isnac                 C  s
   | j tkS )z-
        return if each value is nan
        )r   r   r   rq   rq   rr   r  D  s    zDatetimeLikeArrayMixin._isnanc                 C  s   t | j S )zJ
        return if I have any nans; enables various perf speedups
        )r   r  anyr   rq   rq   rr   _hasnaK  s    zDatetimeLikeArrayMixin._hasna)r   ru   c                 C  s6   | j r2|r||}|du r"tj}t|| 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.
        N)r  r   r   nanputmaskr  )r~   r   
fill_valuer   rq   rq   rr   _maybe_mask_resultsR  s    
z*DatetimeLikeArrayMixin._maybe_mask_resultsz
str | Nonec                 C  s   | j du r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   rq   rq   rr   r  p  s    
zDatetimeLikeArrayMixin.freqstrc                 C  s4   | j dkrdS zt| W S  ty.   Y dS 0 dS )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   re   Z
infer_freqr   r   rq   rq   rr   inferred_freq  s    
z$DatetimeLikeArrayMixin.inferred_freqzResolution | Nonec                 C  s8   | j }|d u rd S zt|W S  ty2   Y d S 0 d S ro   )r  r   Zget_reso_from_freqstrKeyError)r~   r  rq   rq   rr   _resolution_obj  s    z&DatetimeLikeArrayMixin._resolution_objc                 C  s   | j jS )zO
        Returns day, hour, minute, second, millisecond or microsecond
        )r  attrnamer   rq   rq   rr   
resolution  s    z!DatetimeLikeArrayMixin.resolutionc                 C  s   t j| jddd S )NTZtimeliker   r   Zis_monotonicr   r   rq   rq   rr   _is_monotonic_increasing  s    z/DatetimeLikeArrayMixin._is_monotonic_increasingc                 C  s   t j| jddd S )NTr  r   r  r   rq   rq   rr   _is_monotonic_decreasing  s    z/DatetimeLikeArrayMixin._is_monotonic_decreasingc                 C  s   t t| jd| jkS )NK)r   rU   r   r   sizer   rq   rq   rr   
_is_unique  s    z!DatetimeLikeArrayMixin._is_uniquec           
      C  s  | j dkr6t|dd | jkr6||  | | jS z| |}W n tyb   t| || Y S 0 t|dd }t|rt	
|t| t|}|S |tu r|tju rtj| jtd}ntj| jtd}|S t| jts^tt| } | j|jkr^t|t| sJz|j| jdd}W n. tyF   t|j }t!| j"|| Y S 0 n|j"}t!| j"||S | #|}|| j"$d|$d}t%|}| j&|B }|' r|tju }	t(|||	 |S )Nr   r   ry   r   Fr   rw   ))r   r   r   r   r   r   r9   rc   rC   rR   Zcomp_method_OBJECT_ARRAYr   r   r   r   r   operatorneZonesr   r	  rx   ry   rJ   r   TimelikeOpsr   r   r   r   r   r]   Zasm8r$   r   r   rz   rN   r  r  r  )
r~   r   rp   ry   r   Z	other_arrZ
other_valso_maskmaskZ
nat_resultrq   rq   rr   _cmp_method  sL    





z"DatetimeLikeArrayMixin._cmp_method__pow____rpow____mul____rmul____truediv____rtruediv____floordiv____rfloordiv____mod____rmod__
__divmod____rdivmod__z@tuple[int | npt.NDArray[np.int64], None | npt.NDArray[np.bool_]]c                 C  sD   t |tr|j}d}n&t |ttfr0|j}d}n|j}|j}||fS )zN
        Get the int64 values and b_mask to pass to add_overflowsafe.
        N)rx   r   ordinalr   r   r|   r  r   )r~   r   Zi8valuesr&  rq   rq   rr   _get_i8_values_and_mask  s    
z.DatetimeLikeArrayMixin._get_i8_values_and_maskc                 C  s6   t | jtr| jS t|s dS t | jtr2| jS dS )zP
        Check if we can preserve self.freq in addition or subtraction.
        N)rx   ry   rJ   r   r   r   r   r   rq   rq   rr   _get_arithmetic_result_freq*  s    
z2DatetimeLikeArrayMixin._get_arithmetic_result_freqc           
      C  s(  t | jds.tdt| j dt|j td| } ddlm} ddl	m
} |tus\J t|r| jt d| j d	 }|j||jd
S t|}| |\} }td| } | |\}}t| jtj|dd
}|d| j d	}||j| jd}|d| j d	}| |}	|j|||	dS )Nr   cannot add  and rl   r   rj   )tz_to_dtypezM8[]r   rw   r   r   ry   r   )r   is_np_dtypery   r   r   r   r   pandas.core.arraysrj   Zpandas.core.arrays.datetimesr:  r   rN   r   Zto_datetime64r   r   _simple_newr   _ensure_matching_resosr5  r   r   r   r   rz   r   r6  )
r~   r   rj   r:  r   other_i8r%  
res_valuesry   new_freqrq   rq   rr   _add_datetimelike_scalar:  s*    


z/DatetimeLikeArrayMixin._add_datetimelike_scalarc                 C  s6   t | jds.tdt| j dt|j ||  S )Nr   r7  r8  )r   r>  ry   r   r   r   r   rq   rq   rr   _add_datetime_arraylike\  s
    z.DatetimeLikeArrayMixin._add_datetime_arraylikezdatetime | np.datetime64c                 C  sZ   | j jdkr tdt| j td| } t|r:| t S t|}| 	|\} }| 
|S )Nr   "cannot subtract a datelike from a rj   )ry   r   r   r   r   r   rN   r   r   rA  _sub_datetimelike)r~   r   tsrq   rq   rr   _sub_datetimelike_scalarf  s    
z/DatetimeLikeArrayMixin._sub_datetimelike_scalarc                 C  sZ   | j jdkr tdt| j t| t|kr8tdtd| } | |\} }| 	|S )Nr   rG  $cannot add indices of unequal lengthrj   )
ry   r   r   r   r   r   r   r   rA  rH  r   rq   rq   rr   _sub_datetime_arraylikey  s    
z.DatetimeLikeArrayMixin._sub_datetime_arraylikezTimestamp | DatetimeArrayc           
   
   C  s   t d| } ddlm} z| | W nB tyf } z*t|dd}t|||W Y d }~n
d }~0 0 | |\}}t	| j
tj| dd}|d| j d	}| |}	t d
|	}	|j||j|	dS )Nrj   r   rl   comparesubtractrw   r   timedelta64[r;  zTick | Noner=  )r   r?  rl   Z_assert_tzawareness_compatr   rm   replacer   r5  r   r   r   r   rz   r   r6  r@  ry   )
r~   r   rl   r   Znew_messagerB  r%  rC  Zres_m8rD  rq   rq   rr   rH    s    
$

z(DatetimeLikeArrayMixin._sub_datetimeliker   rk   c                 C  s\   t | jds"tdt| j ddlm} t	|j
| j}t|j}|||d}||  S )Nr   zcannot add Period to a r   )rk   r   )r   r>  ry   r   r   r   Zpandas.core.arrays.periodrk   r   Zbroadcast_tor4  r   rJ   r   )r~   r   rk   Zi8valsry   Zparrrq   rq   rr   _add_period  s    
z"DatetimeLikeArrayMixin._add_periodc                 C  s   t | d S ro   r   )r~   offsetrq   rq   rr   _add_offset  s    z"DatetimeLikeArrayMixin._add_offsetc                 C  sj   t |r@tj| jdd| jj}|t t	| j
|| jdS td| } t|}| |\} }| |S )zk
        Add a delta of a timedeltalike

        Returns
        -------
        Same type as self
        rw   r   r  )rN   r   emptyr   rz   r   ry   fillr   r   r@  r   r   rA  _add_timedeltalike)r~   r   
new_valuesrq   rq   rr   _add_timedeltalike_scalar  s    

z0DatetimeLikeArrayMixin._add_timedeltalike_scalar)r   c                 C  s:   t | t |krtdtd| } | |\} }| |S )zl
        Add a delta of a TimedeltaIndex

        Returns
        -------
        Same type as self
        rK  r  )r   r   r   rA  rW  r   rq   rq   rr   _add_timedelta_arraylike  s
    

z/DatetimeLikeArrayMixin._add_timedelta_arraylikezTimedelta | TimedeltaArrayc                 C  s\   t d| } | |\}}t| jtj|dd}|| jj}| 	|}t
| j|| j|dS )Nr  rw   r   r=  )r   r5  r   r   r   r   rz   r   ry   r6  r   r@  )r~   r   rB  r%  rX  rC  rD  rq   rq   rr   rW    s    

z)DatetimeLikeArrayMixin._add_timedeltalikec                 C  sv   t | jtr,tdt| j dttj td| } tj	| j
tjd}|t || jj}t| j|| jddS )z$
        Add pd.NaT to self
        zCannot add r8  zTimedeltaArray | DatetimeArrayr   Nr=  )rx   ry   rJ   r   r   r   r   r   r   rU  r   r   rV  r   rz   r   r@  r~   r   rq   rq   rr   _add_nat  s    

zDatetimeLikeArrayMixin._add_natc                 C  sT   t j| jt jd}|t | jjdv rFtd| } |	d| j
 dS |	dS dS )z+
        Subtract pd.NaT from self
        r   r   zDatetimeArray| TimedeltaArrayrP  r;  ztimedelta64[ns]N)r   rU  r   r   rV  r   ry   r   r   rz   r   r[  rq   rq   rr   _sub_nat  s    

zDatetimeLikeArrayMixin._sub_natzPeriod | PeriodArrayc                   s   t  jts,tdt|j dt j td   |  |\}}t	 j
tj| dd}t fdd|D }|d u r j}n
 j|B }t||< |S )Ncannot subtract  from rk   rw   r   c                   s   g | ]} j j| qS rq   )r   baser   r   r   rq   rr   
<listcomp>  r   z:DatetimeLikeArrayMixin._sub_periodlike.<locals>.<listcomp>)rx   ry   rJ   r   r   r   r   r   r5  r   r   r   r   r]   r  r   )r~   r   rB  r%  Znew_i8_dataZnew_datar&  rq   r   rr   _sub_periodlike  s    


z&DatetimeLikeArrayMixin._sub_periodlikec                 C  s   |t jt jfv sJ t|dkr8| jdkr8|| |d S tjdt| j dt	t
 d | j|jkstJ | j|jf|| dt|}|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.r  O)r"  addsubr   r   r
  r  r   r   r:   r>   r   r   r   r   )r~   r   rp   rC  rq   rq   rr   _addsub_object_array%  s    z+DatetimeLikeArrayMixin._addsub_object_arrayr  )namer  ru   c                K  sV   |dvr t d| dt|  tt|}||  fd|i|}t| j|| jdS )N>   ZcumminZcummaxzAccumulation z not supported for r  r   )r   r   r   rV   r   r@  ry   )r~   rh  r  r   rp   r   rq   rq   rr   _accumulateI  s
    
z"DatetimeLikeArrayMixin._accumulate__add__c                 C  s  t |dd }t|}|tu r(|  }nVt|tttjfrH| 	|}n6t|t
r`| |}nt|ttjfr~| |}n t|trt| jdr| |}nt|rt| jtst| td| }|||jj tj}nt|dr| |}nt|r| |tj}njt|ds.t|tr8|  |S t!|rzt| jtsXt| td| }|||jj tj}nt"S t|tj#rt|jdrddl$m%} |&|S |S )Nry   r   rk   r   r   rM  )'r   r^   r   r\  rx   r   r   r   r   rY  r   rT  r   r   rE  r   r   r>  ry   rR  
is_integerrJ   r&   r   _addsub_int_array_or_scalar_nr"  re  rZ  rC   rg  rH   rF  rA   NotImplementedndarrayr?  rl   r   r~   r   other_dtyper   objrl   rq   rq   rr   rj  R  sF    







zDatetimeLikeArrayMixin.__add__c                 C  s
   |  |S ro   )rj  r   rq   rq   rr   __radd__  s    zDatetimeLikeArrayMixin.__radd____sub__c                 C  s  t |dd }t|}|tu r(|  }nht|tttjfrJ| 	| }nFt|t
rd| | }n,t|ttjfr| |}nt|rt| jtst| td| }|||jj tj}nt|tr| |}nt|dr| | }nt|r| |tj}nt|ds&t|tr2|  |}n^t|trJ| |}nFt!|rt| jtsjt| td| }|||jj tj}nt"S t|tj#rt|jdrddl$m%} |&|S |S )Nry   rk   r   r   r   rM  )'r   r^   r   r]  rx   r   r   r   r   rY  r   rT  r   r   rJ  r   rk  ry   rJ   r&   r   rl  rm  r"  rf  r   rc  r>  rZ  rC   rg  rH   rL  rA   rn  ro  r?  rl   r   rp  rq   rq   rr   rt    sJ    







zDatetimeLikeArrayMixin.__sub__c                 C  s  t |dd }t|dp t|t}|rrt| jdrrt|rJt||  S t|tsjddl	m
} ||}||  S | jjdkrt|dr|stdt| j dt|j nZt| jtrt|drtdt| j d|j n$t| jdrtd| } |  | S | |  S )	Nry   r   r   r   r9  r^  r_  rl   )r   r   r>  rx   rH   ry   r   r   r   r?  rj   r   r   r   r   r   r   rJ   r   )r~   r   rq  Zother_is_dt64rj   rq   rq   rr   __rsub__  s*    




zDatetimeLikeArrayMixin.__rsub__c                 C  s4   | | }|d d  | d d < t | jts0|j| _| S ro   rx   ry   rJ   r   r   r~   r   r   rq   rq   rr   __iadd__  s
    zDatetimeLikeArrayMixin.__iadd__c                 C  s4   | | }|d d  | d d < t | jts0|j| _| S ro   rv  rw  rq   rq   rr   __isub__  s
    zDatetimeLikeArrayMixin.__isub__znpt.NDArray[np.float64])qsinterpolationru   c                   s   t  j||dS )N)rz  r{  )r   	_quantile)r~   rz  r{  r   rq   rr   r|    s    z DatetimeLikeArrayMixin._quantileaxisr  AxisInt | Nonec                K  s8   t d| t || j tj| j||d}| ||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.
        rq   r}  )nvZvalidate_minvalidate_minmax_axisr   rQ   Znanminr   _wrap_reduction_resultr~   r~  r  r   r   rq   rq   rr   min  s    zDatetimeLikeArrayMixin.minc                K  s8   t d| t || j tj| j||d}| ||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.
        rq   r}  )r  Zvalidate_maxr  r   rQ   Znanmaxr   r  r  rq   rq   rr   max  s    zDatetimeLikeArrayMixin.maxr   )r  r~  c                C  sF   t | jtr"tdt| j dtj| j||| 	 d}| 
||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~  r  r&  )rx   ry   rJ   r   r   r   rQ   Znanmeanr   rN   r  )r~   r  r~  r   rq   rq   rr   mean)  s    ,zDatetimeLikeArrayMixin.meanc                K  sH   t d| |d ur*t|| jkr*tdtj| j||d}| ||S )Nrq   z abs(axis) must be less than ndimr}  )	r  Zvalidate_medianabsr   r   rQ   Z	nanmedianr   r  r  rq   rq   rr   medianb  s
    zDatetimeLikeArrayMixin.median)dropnac                 C  sH   d }|r|   }tj| d|d}|| jj}ttj|}| 	|S )Nrw   )r&  )
rN   rO   moderz   r   ry   r   r   ro  r}   )r~   r  r&  Zi8modesZnpmodesrq   rq   rr   _model  s    zDatetimeLikeArrayMixin._modeintznpt.NDArray[np.intp])howhas_dropped_na	min_countngroupsidsc                K  s  | j }|jdkrR|dv r(td| d|dv rtjd| d| dtt d	 ndt|tr|dv rttd
| d|dv rtjd| d| dtt d	 n|dv rtd| d| j	
d}ddlm}	 |	|}
|	||
|d}|j|f|||d d|}|j|jv r|S |j dks$J |dv rddlm} t| j trPtdtd| } d| j d}|
|}|j||j dS |
| j	j }| |S )Nr   )sumprodZcumsumcumprodvarskewz!datetime64 type does not support z operations)r  allr   zh' with datetime64 dtypes is deprecated and will raise in a future version. Use (obj != pd.Timestamp(0)).z() instead.r  zPeriod type does not support ze' with PeriodDtype is deprecated and will raise in a future version. Use (obj != pd.Period(0, freq)).)r  r  r  r  z"timedelta64 type does not support rv   r   )WrappedCythonOp)r  r   r  )r  r  Zcomp_idsr&  )ZstdZsemrM  z-'std' and 'sem' are not valid for PeriodDtyper  zm8[r;  r   )ry   r   r   r
  r  r  r>   rx   rJ   r   rz   Zpandas.core.groupby.opsr  Zget_kind_from_howZ_cython_op_ndim_compatr  Zcast_blocklistr?  rl   r   r   r@  r}   )r~   r  r  r  r  r  r   ry   Znpvaluesr  r   rp   rC  rl   	new_dtyperq   rq   rr   _groupby_opy  sh    



	


z"DatetimeLikeArrayMixin._groupby_op)NNF)F)NN)T).)N)F)F)N)T)`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   rz   r   r   r   r   r   r   r   rY   r   rS   rN   r  r  r   r  r  r  r  r  r  r  r!  r'  rs   r(  r)  r*  r+  r,  r-  r.  r/  r0  r1  r2  r3  r5  r6  rE  rF  rJ  rL  rH  rR  rT  rY  rZ  rW  r\  r]  rc  rg  ri  rb   rj  rs  rt  ru  rx  ry  r   r|  r  r  r  r  r  r  __classcell__rq   rq   r   rr   r      s  
 
 3	(=:U	
9!	

#	
7
7"	9	r   c                   @  s*   e Zd ZdZedddd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)URLrm   r   )r   ru   c                 C  s   | j |tjd}|jtd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   rq   rq   rr   strftime  s    1zDatelikeOps.strftimeN)r   r  r  r  r<   r  rq   rq   rq   rr   r    s
   r  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                      sF  e Zd ZU dZded< dejdfdddd	d
Zedd Z	e
dd ZejddddZeddddZeeddddZedddddZedddd Zed!dd"d#Zd`d!ddd%d&d'Zd(d) Zd*d!d+ fd,d-Zd.d/ Zeee jd0d1dad3d4dd5d6d7Zeee jd8d1dbd3d4dd5d9d:Zeee jd;d1dcd3d4dd5d<d=Z dd$d>d?ddd@dAdBZ!dd$d>d?ddd@dCdDZ"dddEdFZ#dddGdHZ$dId fdJdKZ%dddddL fdMdNZ&ededPdQddR fdSdTZ'dfd!ddV fdWdXZ(dYddZddd[d\d]Z)e
ddd^d_Z*  Z+S )gr$  zK
    Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
    znp.dtype_default_dtypeNFr   r   )r   ru   c           	      C  s  t jt| j dtt d |d ur.t|}t|dd}t|t	rR|j
dtd}t|dd }|d u }|tjurt|nd }t|t| r|rn.|d u r|j}n|r|jrt|}t||j}|d ur||jkrtd| d	|j |j}|j}nX|d u rHt|tjr|jjd
v r|j}n*| j}t|tjrH|jdkrH||}t|tjsxtdt|j dt| j d|jdvrtd|jdkr |d u r| j}|| j}nJt|dr||}n0t|tr | jj}| d|j d}||}| ||}|dkr,tdt| j d|r:|  }|rjt|}|jjdkrjt|t!sjtdt"j#| ||d || _$|d u r|d urt| %| | d S )NzV.__init__ is deprecated and will be removed in a future version. Use pd.array instead.r  Tr   r   Zna_valuer   dtype=z does not match data dtype ZMmrw   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   ry   )&r
  r  r   r   r  r>   rE   r_   rx   r\   r   r   r   r   
no_defaultr   r!   _validate_inferred_freqry   r   r   r   ro  r   r  rz   r   r   r>  rH   r   _validate_dtyper   r   r   r   r   _validate_frequency)	r~   r   ry   r   r   r  Zexplicit_noner   r  rq   rq   rr   r     s    






zTimelikeOps.__init__c                 C  s   t | d S ro   r   )clsr   ry   rq   rq   rr   r    s    zTimelikeOps._validate_dtypec                 C  s   | j S )zK
        Return the frequency object if it is set, otherwise None.
        r   r   rq   rq   rr   r     s    zTimelikeOps.freqr   c                 C  sV   |d urLt |}| | | | jjdkr:t|ts:td| jdkrLtd|| _	d S )Nr   r  r   zCannot set freq with ndim > 1)
r!   r  ry   r   rx   r   r   r   r   r   r   rq   rq   rr   r     s    
dict)validate_kwdsc                 C  s   |du rd| _ nr|dkr0| j du rt| j| _ nR|tju r<nF| j du rnt|}t| j| |fi | || _ n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!   r  r   r  r   r  r  )r~   r   r  rq   rq   rr   _maybe_pin_freq  s    


zTimelikeOps._maybe_pin_freqr   r   c              
   K  s   |j }|jdks||jkrdS z>| jf |d dt|||jd|}t|j|jsZt	W nL t	y } z4dt
|v r||t	d| d|j |W Y d}~n
d}~0 0 dS )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  r   r  _generate_ranger   r   r   Zarray_equalr   r   rm   )r  indexr   r   r  Zon_freqr   rq   rq   rr   r  0  s2    zTimelikeOps._validate_frequency
int | Noner2   r  ru   c                 O  s   t | d S ro   r   )r  r  r  r  r   r   r   rq   rq   rr   r  \  s    zTimelikeOps._generate_ranger  c                 C  s   t | jjS ro   )r   r   ry   r   rq   rq   rr   r   d  s    zTimelikeOps._cresorm   c                 C  s
   t | jS ro   )dtype_to_unitry   r   rq   rq   rr   r   h  s    zTimelikeOps.unitT)r   r   ru   c                 C  s~   |dvrt dt| jj d| d}t| j||d}t| jtjrP|j}ntd| j}t	||d}t
| j||| jdS )	N)smsusnsz)Supported units are 's', 'ms', 'us', 'ns'r  r;  r   rj   r<  r=  )r   r   ry   r   r   r   rx   r   r   rH   r   r@  r   )r~   r   r   ry   rX  r  r   rq   rq   rr   r   o  s    zTimelikeOps.as_unitc                 C  s:   | j |j kr2| j |j k r&| |j} n|| j}| |fS ro   )r   r   r   r   rq   rq   rr   rA    s
    z"TimelikeOps._ensure_matching_resosznp.ufunc)ufuncmethodc                   s`   |t jt jt jfv rDt|dkrD|d | u rDt||| 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   rq   rr   r    s    

zTimelikeOps.__array_ufunc__c           
      C  s   t | jtrBtd| } | d }|||||}|j| j||dS | d}ttj	|}t
|| j}|dkrt|  S t|||}	| j|	td}|| jj}| j|| jdS )Nrj   )	ambiguousnonexistentrw   r   r  r   )rx   ry   rH   r   Ztz_localize_roundr   rz   r   ro  r%   r   r   r#   r  r   r   r@  )
r~   r   r  r  r  Znaiver   r   ZnanosZ	result_i8rq   rq   rr   r    s     


zTimelikeOps._roundround)rp   raiser4   r5   )r  r  ru   c                 C  s   |  |tj||S ro   )r  r"   ZNEAREST_HALF_EVENr~   r   r  r  rq   rq   rr   r    s    zTimelikeOps.roundfloorc                 C  s   |  |tj||S ro   )r  r"   ZMINUS_INFTYr  rq   rq   rr   r    s    zTimelikeOps.floorceilc                 C  s   |  |tj||S ro   )r  r"   Z
PLUS_INFTYr  rq   rq   rr   r    s    zTimelikeOps.ceilr}  r  )r~  r  ru   c                C  s   t j| j|||  dS Nr  )rQ   Znananyr   rN   r~   r~  r  rq   rq   rr   r    s    zTimelikeOps.anyc                C  s   t j| j|||  dS r  )rQ   Znanallr   rN   r  rq   rq   rr   r    s    zTimelikeOps.allc                 C  s
   d | _ d S ro   r  r   rq   rq   rr   r     s    zTimelikeOps._maybe_clear_freqc                 C  sh   |du r
nLt | dkr@t|tr@| jjdkrVt|tsVtdn|dksLJ 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   rx   r   ry   r   r   r   r!   r  rz   r   )r~   r   r   rq   rq   rr   
_with_freq  s    

zTimelikeOps._with_freqr   c                   s   t | jtjr| jS t  S ro   )rx   ry   r   r   r   _values_for_jsonr   r   rq   rr   r    s    zTimelikeOps._values_for_json)use_na_sentinelsortc                   s   | j d urZtjt| tjd}|  }|rR| j jdk rR|d d d }|d d d }||fS |rttdt| j	 dt
 j|d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   Zaranger   Zintpr   r   NotImplementedErrorr   r   r   	factorize)r~   r  r  codesZuniquesr   rq   rr   r  	  s    
zTimelikeOps.factorizer   zSequence[Self]r(   )	to_concatr~  ru   c                   s   t  ||}|d  |dkrdd |D } jd urt fdd|D rt|d d |dd  }t fdd|D r j}||_|S )	Nr   c                 S  s   g | ]}t |r|qS rq   )r   ra  rq   rq   rr   rb  (	  r   z1TimelikeOps._concat_same_type.<locals>.<listcomp>c                 3  s   | ]}|j  j kV  qd S ro   r  ra  rr  rq   rr   r   *	  r   z0TimelikeOps._concat_same_type.<locals>.<genexpr>r  r   c                 3  s,   | ]$}|d  d  j  |d d  kV  qdS )r   r  r   Nr  )r   pairr  rq   rr   r   ,	  r   )r   _concat_same_typer   r  zipr   )r  r  r~  new_objpairsrD  r   r  rr   r  	  s     zTimelikeOps._concat_same_typeC)orderru   c                   s   t  j|d}| j|_|S )N)r  )r   r   r   r   )r~   r  r  r   rq   rr   r   1	  s    zTimelikeOps.copyr-   ri   )r  r~  r  r   ru   c          
   	   K  s^   |dkrt |s| j}	n
| j }	tj|	f||||||d| |sJ| S t| j|	| jdS )z2
        See NDFrame.interpolate.__doc__.
        Zlinear)r  r~  r  limitlimit_direction
limit_arear   )r  r   r   rP   Zinterpolate_2d_inplacer   r@  ry   )
r~   r  r~  r  r  r  r  r   r   Zout_datarq   rq   rr   interpolate6	  s(    

zTimelikeOps.interpolatec                 C  sP   t | jsdS | j}|tk}t| j}t|}t||| 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>  ry   r   r   r   r    r   logical_andr  )r~   Z
values_intZconsider_valuesr   ZppdZ	even_daysrq   rq   rr   _is_dates_only_	  s    
zTimelikeOps._is_dates_only)T)r  r  )r  r  )r  r  )TF)r   )r  ),r   r  r  r  r  r   r  r   classmethodr  r  r   setterr   r  r  r  r=   r   r   r   rA  r  r  r;   
_round_doc_round_exampler   r  _floor_exampler  _ceil_exampler  r  r  r   r  r  r  r  r   r  r  r  rq   rq   r   rr   r$    sh   
\

 *          )r$  r   ztuple[ArrayLike, bool])r   cls_nameru   c                 C  s   t | ds<t| ttfs.t| dkr.t| } t| } d}n(t| trXtd| dnt	| dd} t| t
st| tr| jjdv r| jd	td
} d}n^t| tr|  } |  } d}n>t| tjtfst| } n"t| tr| jj| jtdj} d}| |fS )Nry   r   FzCannot create a z from a MultiIndex.Tr   r   r   r  r  )r   rx   r   tupler   r   r?   rL   r   r_   r\   rZ   ry   r   r   r   Z_maybe_convert_datelike_arrayro  r[   r   rK   r   Ztaker  r   Z_values)r   r   r  rq   rq   rr   !ensure_arraylike_for_datetimelikey	  s2    





r  r   r  c                 C  s   d S ro   rq   r  rq   rq   rr   validate_periods	  s    r  zint | floatr  c                 C  s   d S ro   rq   r  rq   rq   rr   r  	  s    zint | float | Noner  c                 C  sJ   | durFt | r.tjdtt d t| } nt | sFt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.r  zperiods must be a number, got )	r   Zis_floatr
  r  r  r>   r  rk  r   r  rq   rq   rr   r  	  s    


r   )r   r  ru   c                 C  s>   |dur:| dur.| |kr.t d| d| j | du r:|} | 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
    Nr  r  )r   r  )r   r  rq   rq   rr   r  	  s    r  z'DatetimeTZDtype | np.dtype | ArrowDtyper   c                 C  sJ   t | tr| jS t | tr<| jdvr4td| d| jjS t| 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   )	rx   rH   r   rF   r   r   Zpyarrow_dtyper   Zdatetime_datar   rq   rq   rr   r  	  s    


r  )
__future__r   r   r   	functoolsr   r"  typingr   r   r   r	   r
   r   r   r   r
  numpyr   Zpandas._libsr   r   Zpandas._libs.arraysr   Zpandas._libs.tslibsr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r    r!   Zpandas._libs.tslibs.fieldsr"   r#   Zpandas._libs.tslibs.np_datetimer$   Zpandas._libs.tslibs.timedeltasr%   Zpandas._libs.tslibs.timestampsr&   Zpandas._typingr'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   Zpandas.compat.numpyr7   r  Zpandas.errorsr8   r9   r:   Zpandas.util._decoratorsr;   r<   r=   Zpandas.util._exceptionsr>   Zpandas.core.dtypes.castr?   Zpandas.core.dtypes.commonr@   rA   rB   rC   rD   rE   Zpandas.core.dtypes.dtypesrF   rG   rH   rI   rJ   Zpandas.core.dtypes.genericrK   rL   Zpandas.core.dtypes.missingrM   rN   Zpandas.corerO   rP   rQ   rR   Zpandas.core.algorithmsrS   rT   rU   Zpandas.core.array_algosrV   Zpandas.core.arraylikerW   Zpandas.core.arrays._mixinsrX   rY   Zpandas.core.arrays.arrow.arrayrZ   Zpandas.core.arrays.baser[   Zpandas.core.arrays.integerr\   Zpandas.core.commoncorecommonr   Zpandas.core.constructionr]   r   r^   r_   Zpandas.core.indexersr`   ra   Zpandas.core.ops.commonrb   Zpandas.core.ops.invalidrc   rd   Zpandas.tseriesre   collections.abcrf   rg   r   ri   r?  rj   rk   rl   r   rs   r   r   r  r  r  r  r  r$  r  r  r  r  rq   rq   rq   rr   <module>   s   (
LH 
            :?   h'"