U
    c5                    @  s  d dl mZ d dlmZ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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& d dl'm(Z(m)Z) d d	l*m+Z+ d d
l,m-Z- d dl.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8 d dl9m:Z; d dl<m=Z=m>Z>m?Z? d dl@mAZAmBZBmCZC d dlDmEZE d dlFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRmSZSmTZTmUZUmVZV d dlWmXZXmYZY d dlZm[Z[m\Z\ d dl]m^Z^m_Z_ d dl`maZambZb d dlcmdZdmeZemfZfmgZg d dlhmiZi d dljmkZkmlZl d dlmmnZn d dlompZp d dlqmr  msZt d dlumvZwmxZxmyZy d dlzm{Z{m|Z| d dl}m~Z~ d dlmZmZ d dlmZ erd dlmZmZmZ ee0ef Zed d!d"ZG d#d$ d$eZG d%d! d!eiekZG d&d' d'eZd(Zd)Zd*Zd+Zed,d-d"ZG d.d- d-eZd/d0d1d2d3Zed4d4d5d6d7Zed8d9d5d:d7Zd;d<d5d=d7Zd>d?d@dAZdBdC ZdDd0dEdFdGZdS )H    )annotations)datetime	timedeltaN)
TYPE_CHECKINGAnyCallableLiteralSequenceTypeVarUnioncastfinaloverload)algoslib)NDArrayBacked)
BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod
ResolutionTick	Timestampdelta_to_nanosecondsget_unit_from_dtypeiNaTints_to_pydatetimeints_to_pytimedelta	to_offset)RoundToround_nsint64)compare_mismatched_resolutions)integer_op_not_supported)
	ArrayLikeDatetimeLikeScalarDtypeDtypeObjNpDtypePositionalIndexer2DPositionalIndexerTupleScalarIndexerSequenceIndexernpt)function)AbstractMethodErrorNullFrequencyErrorPerformanceWarning)AppenderSubstitutioncache_readonly)find_stack_level)is_all_stringsis_categorical_dtypeis_datetime64_any_dtypeis_datetime64_dtypeis_datetime64tz_dtypeis_datetime_or_timedelta_dtypeis_dtype_equalis_float_dtypeis_integer_dtypeis_list_likeis_object_dtypeis_period_dtypeis_string_dtypeis_timedelta64_dtypeis_unsigned_integer_dtypepandas_dtype)DatetimeTZDtypeExtensionDtype)ABCCategoricalABCMultiIndex)is_valid_na_for_dtypeisna)nanopsops)checked_add_with_arrisinmodeunique1d)OpsMixin)NDArrayBackedExtensionArrayravel_compat)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)DatetimeArrayPeriodArrayTimedeltaArrayDatetimeLikeArrayTDatetimeLikeArrayMixin)boundc                   @  s   e Zd ZdZdS )InvalidComparisonzm
    Raised by _validate_comparison_value to indicate to caller it should
    return invalid_comparison.
    N)__name__
__module____qualname____doc__ rk   rk   C/tmp/pip-unpacked-wheel-g7fro6k3/pandas/core/arrays/datetimelike.pyrf      s   rf   c                      s  e Zd ZU dZded< ded< ded< ded	< ed
dddZddddddZeddddZ	dddddZ
ddd
dddd Zddd
dd!d"d#Zeddd$d%Zd&d' Zddd(d)Zd*d+ Zed,dd-d.Zd/dd0d1dd2d3Zdd
d4d5d6Zdd7ddd8d9Zed:dd;d<d=Zed>d?d>d@dAd=Zd>dBdCdD fdEd=ZdFddGdHZdIdJddK fdLdMZdNdO Zdd
dQ fdRdSZed>d>dTdUdVZedWdXddYdVZedZd[dd\dVZeddd^dd_dVZddd^d fd`dVZeddbdcddd>de fdfdgZdd>d>dT fdidjZdkdl Zdmdn Z ddPdPdod
d
d
dodpdqZ!dd
ddrdsdtZ"dd
dudvdwZ#dxdy Z$dzd{ Z%dd
d|d}d~dZ&e'dd Z(ddddZ)ddddZ*eddddZ+ed
dddZ,e-dfdddddZ.edd Z/e/j0ddddZ/eddddZ1eddddZ2eddddZ3eddddZ4edd Z5edbd>dddZ6ed
dddZ7ed
dddZ8ed
dddZ9dd Z:e;dZ<e;dZ=e;dZ>e;dZ?e;dZ@e;dZAe;dZBe;dZCe;dZDe;dZEe;dZFe;dZGeHdXdddZIeHdXdddZJeHddddZKeHdd ZLeHdd1dddZMeHdddddĄZNddƄ ZOddȄ ZPdddd˄ZQeHdd̈́ ZReHddτ ZSeHdd1dddфZTeHddddӄZUd d>ddd>dԜddքZVeWd׃ddل ZXddۄ ZYeWd܃ddބ ZZdd Z[d>d>dTddZ\d>d>dTddZ]ddPddd
dddZ^ddPddd
dddZ_dPdadd
ddddZ`ddPddd
dddZadd
dddZb  ZcS (  rd   z
    Shared Base/Mixin class for DatetimeArray, TimedeltaArray, PeriodArray

    Assumes that __new__/__init__ defines:
        _data
        _freq

    and that the inheriting class has methods:
        _generate_range
    ztuple[str, ...]_infer_matcheszCallable[[DtypeObj], bool]_is_recognized_dtypeztuple[type, ...]_recognized_scalarsz
np.ndarray_ndarrayboolreturnc                 C  s   dS )NTrk   selfrk   rk   rl   _can_hold_na   s    z#DatetimeLikeArrayMixin._can_hold_naNFzDtype | NoneNonedtypers   c                 C  s   t | d S Nr/   )ru   datary   freqcopyrk   rk   rl   __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{   rt   rk   rk   rl   _scalar_type   s    	z#DatetimeLikeArrayMixin._scalar_typestrDTScalarOrNaT)valuers   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{   ru   r   rk   rk   rl   _scalar_from_string   s    z*DatetimeLikeArrayMixin._scalar_from_stringz)np.int64 | np.datetime64 | np.timedelta64)r   setitemrs   c                 C  s   t | dS )a  
        Unbox the integer value of a scalar `value`.

        Parameters
        ----------
        value : Period, Timestamp, Timedelta, or NaT
            Depending on subclass.
        setitem : bool, default False
            Whether to check compatibility with setitem strictness.

        Returns
        -------
        int

        Examples
        --------
        >>> self._unbox_scalar(Timedelta("10s"))  # doctest: +SKIP
        10000000000
        Nr{   )ru   r   r   rk   rk   rl   _unbox_scalar   s    z$DatetimeLikeArrayMixin._unbox_scalar)otherr   rs   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
        setitem : bool, default False
            For __setitem__ we may have stricter compatibility restrictions than
            for comparisons.

        Raises
        ------
        Exception
        Nr{   ru   r   r   rk   rk   rl   _check_compatible_with   s    z-DatetimeLikeArrayMixin._check_compatible_withc                 C  s   | j S rz   )rp   rt   rk   rk   rl   _data  s    zDatetimeLikeArrayMixin._datac                 C  s   t | dS )zI
        box function to get object from internal representation
        Nr{   )ru   xrk   rk   rl   	_box_func  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   )ru   valuesrk   rk   rl   _box_values  s    z"DatetimeLikeArrayMixin._box_valuesc                   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 rz   rk   ).0nrt   rk   rl   	<genexpr>#  s     z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>c                 3  s   | ]}  |V  qd S rz   )r   )r   vrt   rk   rl   r   %  s     )ndimrangelenasi8rt   rk   rt   rl   __iter__!  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.
        i8)rp   viewrt   rk   rk   rl   r   '  s    zDatetimeLikeArrayMixin.asi8r   )na_repdate_formatnpt.NDArray[np.object_]c                C  s   t | dS )z|
        Helper method for astype when converting to strings.

        Returns
        -------
        ndarray[str]
        Nr{   )ru   r   r   rk   rk   rl   _format_native_types7  s    
z+DatetimeLikeArrayMixin._format_native_types)boxedc                 C  s   dj S )Nz'{}')format)ru   r   rk   rk   rl   
_formatterC  s    z!DatetimeLikeArrayMixin._formatterzNpDtype | Nonec                 C  s    t |rtjt| tdS | jS )Nry   )r@   nprW   listobjectrp   ru   ry   rk   rk   rl   	__array__J  s    z DatetimeLikeArrayMixin.__array__r+   )itemrs   c                 C  s   d S rz   rk   ru   r   rk   rk   rl   __getitem__P  s    z"DatetimeLikeArrayMixin.__getitem__rc   z(SequenceIndexer | PositionalIndexerTuple)ru   r   rs   c                 C  s   d S rz   rk   r   rk   rk   rl   r   T  s    r)   z"DatetimeLikeArrayT | DTScalarOrNaT)ru   keyrs   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[DatetimeLikeArrayT, DTScalarOrNaT])r   superr   r   	is_scalarrc   _get_getitem_freq_freq)ru   r   result	__class__rk   rl   r   [  s    
 


zBaseOffset | Nonec                 C  s   t | j}|r| j}n| jdkr&d}nt| |}d}t|trh| jdk	r`|jdk	r`|j| j }q| j}n@|tkrx| 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)rA   ry   r}   r   rZ   
isinstanceslicestepEllipsiscomZis_bool_indexerr   Zmaybe_booleans_to_slicer   r   Zuint8r   )ru   r   Z	is_periodr}   Znew_keyrk   rk   rl   r   p  s$    






z(DatetimeLikeArrayMixin._get_getitem_freqz,int | Sequence[int] | Sequence[bool] | slicezNaTType | Any | Sequence[Any])r   r   rs   c                   s.   t ||| }t || |r"d S |   d S rz   )r[   r   __setitem___maybe_clear_freq)ru   r   r   Zno_opr   rk   rl   r     s
    z"DatetimeLikeArrayMixin.__setitem__c                 C  s   d S rz   rk   rt   rk   rk   rl   r     s    z(DatetimeLikeArrayMixin._maybe_clear_freqTr~   c                   s  t |}t|rz| jjdkrHtd| } | j}t|| j| jd| j	d}|S | jjdkrbt
| jddS | | j | jS t|trt j||dS t|r|  S t|rl| j}t|r,|d	}|tjk rtjd
| j d| dtt d n2| jdk  rZtjd
| j d| dtt d n.|tj krZtjd
| j d| dtt d |rh|! }|S t"|rt#| j|rt$|rdt%| j& d| }t'|ntj(| |dS d S )NMr`   	timestamp)tzr}   boxresomT)r   r   uint64zThe behavior of .astype from z to z is deprecated. In a future version, this astype will return exactly the specified dtype instead of uint64, and will raise if that conversion overflows.
stacklevelr   z is deprecated. In a future version, this astype will raise if the conversion overflows, as it did in this case with negative int64 values.z is deprecated. In a future version, this astype will return exactly the specified dtype instead of int64, and will raise if that conversion overflows.zCannot cast z
 to dtype r   ))rE   r@   ry   kindr   r   r   r   r}   _resor   rp   r   ravelreshapeshaper   rG   r   astyperB   r   r>   rD   r   r   r   warningswarnFutureWarningr5   anyint64r~   r;   r<   r=   typerg   	TypeErrorasarray)ru   ry   r~   Zi8dataZ	convertedr   msgr   rk   rl   r     sl    




	

zDatetimeLikeArrayMixin.astype)ru   rs   c                 C  s   d S rz   rk   rt   rk   rk   rl   r     s    zDatetimeLikeArrayMixin.viewzLiteral['M8[ns]']r`   c                 C  s   d S rz   rk   r   rk   rk   rl   r     s    zLiteral['m8[ns]']rb   c                 C  s   d S rz   rk   r   rk   rk   rl   r     s    .r$   c                 C  s   d S rz   rk   r   rk   rk   rl   r   	  s    c                   s   t  |S rz   )r   r   r   r   rk   rl   r     s    r   ztype[DatetimeLikeArrayT]zSequence[DatetimeLikeArrayT]int)cls	to_concataxisrs   c                   s   t  ||}|d   j}d }t|r0 j}nl|dkrdd |D } jd k	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 rk   )r   r   r   rk   rk   rl   
<listcomp>&  s      z<DatetimeLikeArrayMixin._concat_same_type.<locals>.<listcomp>c                 3  s   | ]}|j  j kV  qd S rz   r}   r   objrk   rl   r   (  s     z;DatetimeLikeArrayMixin._concat_same_type.<locals>.<genexpr>r   c                 3  s,   | ]$}|d  d  j  |d d  kV  qdS )r   r   r   Nr   )r   pairr   rk   rl   r   *  s     )r   _concat_same_typery   rA   r}   allzipr   )r   r   r   new_objry   new_freqpairsr   r   rl   r     s     z(DatetimeLikeArrayMixin._concat_same_typeCc                   s   t  j|d}| j|_|S )N)order)r   r~   r}   r   )ru   r   r   r   rk   rl   r~   0  s    zDatetimeLikeArrayMixin.copyc              
   C  s.  t |tr:z| |}W n  ttfk
r8   t|Y nX t || jsN|tkr| |}z| 	| W n0 t
tfk
r } zt||W 5 d }~X Y nX nt|st|n~t|t| krtdndz| j|dd}| 	| W nF t
tfk
r( } z"tt|dd rn
t||W 5 d }~X Y nX |S )NzLengths must matchTallow_objectry   )r   r   r   
ValueErrorr   rf   ro   r   r   r   r   r?   r   _validate_listliker@   getattr)ru   r   errrk   rk   rl   _validate_comparison_value:  s.    



z1DatetimeLikeArrayMixin._validate_comparison_valuec                 C  s   t || jrt}ntt|| jr*| |}n\| jtkrPt|rPtj	|| j
d}n
| |}tjdt| d| jj dtt d |}| j|ddS )Nr   zPassing zA to shift is deprecated and will raise in a future version, pass z	 instead.r   Tr   )rJ   ry   r   r   ro   r   r   r   
is_integerZ_from_ordinalr}   r   r   r   rg   r   r5   _unbox)ru   
fill_valueZnew_fillrk   rk   rl   _validate_shift_value^  s    
	z,DatetimeLikeArrayMixin._validate_shift_value)allow_listliker   unboxc             
   C  s   t || jrnt |trbz| |}W q tk
r^ } z| ||}t||W 5 d}~X Y qX n\t|| jrtt	}nJt
|r| ||}t|n,t || jr| |}n| ||}t||s|S | j||dS )av  
        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.
        setitem : bool, default True
            Whether to check compatibility with setitem strictness.
        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
        Nr   )r   r   r   r   r   _validation_error_messager   rJ   ry   r   rK   ro   r   )ru   r   r   r   r   r   r   rk   rk   rl   _validate_scalar}  s(    

z'DatetimeLikeArrayMixin._validate_scalar)r   rs   c                 C  sB   |r"d| j j dt|j d}nd| j j dt|j 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
        zvalue should be a 'z"', 'NaT', or array of those. Got 'z
' instead.z' or 'NaT'. Got ')r   rg   r   )ru   r   r   r   rk   rk   rl   r     s    z0DatetimeLikeArrayMixin._validation_error_messager   c              	   C  sv  t |t| r|S t |tr<t|dkr<t| jg | jdS t|dr|jtkrt	|| j
krzt| |}W n8 ttfk
r   |r| Y S | |d}t|Y nX t|dd}t|}t|dd}t|rzt| j|| jd}W n tk
r   Y nX t|jr8t|jj| jr8| }t|dd}|rLt|jrLn&t| |jsr| |d}t||S )Nr   r   ry   TZextract_numpy)r   r   r   r   _from_sequencery   hasattrr   r   infer_dtyperm   r   r   r   rY   pd_arrayr6   r7   r<   
categoriesZ_internal_get_valuesr@   rn   )ru   r   r   r   rk   rk   rl   r     s>    
z)DatetimeLikeArrayMixin._validate_listlikec                 C  s,   t |s| j|dddS | |}| |S )NTF)r   r   )r?   r   r   r   r   rk   rk   rl   _validate_searchsorted_value	  s    
z3DatetimeLikeArrayMixin._validate_searchsorted_valuec                 C  s0   t |r| |}n| j|ddS | j|ddS )NT)r   r   )r?   r   r   r   r   rk   rk   rl   _validate_setitem_value  s    z.DatetimeLikeArrayMixin._validate_setitem_valuez6np.int64 | np.datetime64 | np.timedelta64 | np.ndarray)r   rs   c                 C  s2   t |r| j||d}n| j||d |j}|S )zZ
        Unbox either a scalar with _unbox_scalar or an instance of our own type.
        r   )r   r   r   r   rp   r   rk   rk   rl   r     s
    
zDatetimeLikeArrayMixin._unboxc                 C  s   ddl m} || |jS )Nr   )Index)Zpandasr   maprW   )ru   Zmapperr   rk   rk   rl   r  ,  s    zDatetimeLikeArrayMixin.mapznpt.NDArray[np.bool_]c              	   C  s   t |dst|}|jjdkr0tj| jtdS t|t	| sdddddd	g}|jt
krtj|d
d}||kr|dkrxn(d|krt| t
|S tj| jtdS zt	| |}W n$ tk
r   t| t
| Y S X z| | W n* ttfk
r   tj| jtd Y S X t| j|jS )z
        Compute boolean array of whether each value is found in the
        passed set of values.

        Parameters
        ----------
        values : set or sequence of values

        Returns
        -------
        ndarray[bool]
        ry   )fiucr   r   timedelta64r   
datetime64dateZperiodF)skipnastringmixed)r   r   r   ry   r   zerosr   rq   r   r   r   r   r   rO   r   r   r   r   r   r   )ru   r   Z	inferableinferredrk   rk   rl   rO   7  s:    


zDatetimeLikeArrayMixin.isinc                 C  s   | j S rz   )_isnanrt   rk   rk   rl   rK   o  s    zDatetimeLikeArrayMixin.isnac                 C  s
   | j tkS )z-
        return if each value is nan
        )r   r   rt   rk   rk   rl   r  r  s    zDatetimeLikeArrayMixin._isnanc                 C  s   t | j S )zJ
        return if I have any nans; enables various perf speedups
        )rq   r  r   rt   rk   rk   rl   _hasnay  s    zDatetimeLikeArrayMixin._hasna)r   rs   c                 C  s6   | j r2|r||}|dk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  )ru   r   r   r   rk   rk   rl   _maybe_mask_results  s    
z*DatetimeLikeArrayMixin._maybe_mask_resultsc                 C  s   | j S )zK
        Return the frequency object if it is set, otherwise None.
        r   rt   rk   rk   rl   r}     s    zDatetimeLikeArrayMixin.freqc                 C  s8   |d k	r.t |}| | | | jdkr.td|| _d S )Nr   zCannot set freq with ndim > 1)r   _validate_frequencyr   r   r   r   rk   rk   rl   r}     s    
z
str | Nonec                 C  s   | j dkrdS | j jS )zU
        Return the frequency object as a string if its set, otherwise None.
        N)r}   freqstrrt   rk   rk   rl   r    s    
zDatetimeLikeArrayMixin.freqstrc                 C  s6   | j dkrdS zt| W S  tk
r0   Y dS X dS )z
        Tries to return a string representing a frequency generated by infer_freq.

        Returns None if it can't autodetect the frequency.
        r   N)r   r_   Z
infer_freqr   rt   rk   rk   rl   inferred_freq  s    
z$DatetimeLikeArrayMixin.inferred_freqzResolution | Nonec                 C  s:   | j }|d krd S zt|W S  tk
r4   Y d S X d S rz   )r  r   Zget_reso_from_freqstrKeyError)ru   r  rk   rk   rl   _resolution_obj  s    z&DatetimeLikeArrayMixin._resolution_objc                 C  s   | j jS )zO
        Returns day, hour, minute, second, millisecond or microsecond
        )r  attrnamert   rk   rk   rl   
resolution  s    z!DatetimeLikeArrayMixin.resolutionc              
   K  s   |j }|jdks||jkrdS z:| jf |d dt||d|}t|j|jsVtW nJ tk
r } z,dt	|krz|td| d|j |W 5 d}~X Y nX 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}   z	non-fixedInferred frequency 9 from passed values does not conform to passed frequency )
r  sizer  _generate_ranger   r   Zarray_equalr   r   r   )r   indexr}   kwargsr  Zon_freqerk   rk   rl   r    s,       z*DatetimeLikeArrayMixin._validate_frequency)r   rs   c                 O  s   t | d S rz   r{   )r   r  r  r  r}   argsr$  rk   rk   rl   r"     s    z&DatetimeLikeArrayMixin._generate_rangec                 C  s   t j| jddd S )NTZtimeliker   r   Zis_monotonicr   rt   rk   rk   rl   _is_monotonic_increasing	  s    z/DatetimeLikeArrayMixin._is_monotonic_increasingc                 C  s   t j| jddd S )NTr'  r   r(  rt   rk   rk   rl   _is_monotonic_decreasing  s    z/DatetimeLikeArrayMixin._is_monotonic_decreasingc                 C  s   t t| jd| jkS )NK)r   rQ   r   r   r!  rt   rk   rk   rl   
_is_unique  s    z!DatetimeLikeArrayMixin._is_uniquec           
   	   C  s  | j dkr6t|dd | jkr6||  | | jS z| |}W n  tk
rd   t| || Y S X t|dd }t|rt	j
dd  t|t	| t|}W 5 Q R X |S |tkr|tjkrt	j| jtd}nt	j| jtd}|S t| js>tt| } | j|jkr>t|t| s*t	|j}n|j}t | j||S | !|}|| j"d|"d}t#|}| j$|B }|% r|tjk}	t	&|||	 |S )Nr   r   ry   ignore)r   r   r   )'r   r   r   r   r   r   rf   r]   r@   r   ZerrstaterM   Zcomp_method_OBJECT_ARRAYr   r   r   r   operatorneZonesrq   r  rA   ry   r   TimelikeOpsr   r   r   rW   Zasm8rp   r"   r   r   rK   r  r   r  )
ru   r   opry   r   Z	other_arrZ
other_valsZo_maskmaskZ
nat_resultrk   rk   rl   _cmp_method  sF      





z"DatetimeLikeArrayMixin._cmp_method__pow____rpow____mul____rmul____truediv____rtruediv____floordiv____rfloordiv____mod____rmod__
__divmod____rdivmod__c                 C  s   t | js*tdt| j dt|j td| } ddlm} ddlm	} |t
k	sXtt|}|t
kr| jt
 d| j d }|j||jd	S | j|jkrtd
| j}t||j| jd}||j| jd}|d| j d}|j||| jdS )Ncannot add  and rb   r   r`   )tz_to_dtypezM8[]r   z`Addition between TimedeltaArray and Timestamp with mis-matched resolutions is not yet supported.arr_mask)r   unitry   r}   )rC   ry   r   r   rg   r   pandas.core.arraysr`   Zpandas.core.arrays.datetimesrC  r   AssertionErrorr   rp   Zto_datetime64r   _unit_simple_newr   NotImplementedErrorr   rN   r   r  r   r   r}   )ru   r   r`   rC  r   r   ry   
res_valuesrk   rk   rl   _add_datetimelike_scalarZ  s*    

z/DatetimeLikeArrayMixin._add_datetimelike_scalarc                 C  s:   t | js*tdt| j dt|j t|}||  S )Nr@  rA  )rC   ry   r   r   rg   rX   ru   r   rk   rk   rl   _add_datetime_arraylike{  s    
z.DatetimeLikeArrayMixin._add_datetime_arraylikezdatetime | np.datetime64)r   c              
   C  s   | j jdkr tdt| j td| } |tk	s6tt|}|tkrN| t S z| 	| W n@ tk
r } z"t
|dd}t|||W 5 d }~X Y nX | j}t||j | jd}|dS )Nr   "cannot subtract a datelike from a r`   comparesubtractrE  timedelta64[ns])ry   r   r   r   rg   r   r   rJ  r   _assert_tzawareness_compatr   replacer   rN   r   r  r   )ru   r   r   new_messager   r   rk   rk   rl   _sub_datetimelike_scalar  s    
 z/DatetimeLikeArrayMixin._sub_datetimelike_scalarc              
   C  s   | j jdkr tdt| j t| t|kr8tdtd| } t|}z| 	| W n@ tk
r } z"t
|dd}t|||W 5 d }~X Y nX | j}|j}t|| | j|jd}|dS )	Nr   rR  $cannot add indices of unequal lengthr`   rS  rT  rF  Zb_maskrU  )ry   r   r   r   rg   r   r   r   rX   rV  r   rW  r   rN   r  r   )ru   r   r   rX  self_i8other_i8
new_valuesrk   rk   rl   _sub_datetime_arraylike  s(    
    z.DatetimeLikeArrayMixin._sub_datetime_arrayliker   )r   rs   c                   sj   t  jstdt j  | t j|j  j	d}t
 fdd|D } jrft| j	< |S )Nzcannot subtract Period from a rE  c                   s   g | ]} j j| qS rk   r}   baser   rt   rk   rl   r     s     z6DatetimeLikeArrayMixin._sub_period.<locals>.<listcomp>)rA   ry   r   r   rg   r   rN   r   ordinalr  r   rW   r  r   )ru   r   Znew_i8_dataZnew_datark   rt   rl   _sub_period  s    

  
z"DatetimeLikeArrayMixin._sub_periodra   c                 C  sP   t | jstdt| j ddlm} t|j	| j
}|||jd}||  S )Nzcannot add Period to a r   )ra   r   )rC   ry   r   r   rg   Zpandas.core.arrays.periodra   r   Zbroadcast_torb  r   r}   )ru   r   ra   Zi8valsZparrrk   rk   rl   _add_period  s    
z"DatetimeLikeArrayMixin._add_periodc                 C  s   t | d S rz   r{   )ru   offsetrk   rk   rl   _add_offset  s    z"DatetimeLikeArrayMixin._add_offsetc                 C  s   t |r@tj| jdd| jj}|t t	| j
|| jdS t|| jd}t| j|| jd}|| jj}d}t| jtst| jr| j}t	| j
|| j|dS )zk
        Add a delta of a timedeltalike

        Returns
        -------
        Same type as self
        r   r   )r   rE  NrH  )rK   r   emptyr   r   rp   ry   fillr   r   rL  r   r   rN   r   r  r   r}   r   rA   )ru   r   r^  incr   rk   rk   rl   _add_timedeltalike_scalar  s    
  z0DatetimeLikeArrayMixin._add_timedeltalike_scalarz,TimedeltaArray | npt.NDArray[np.timedelta64]c                 C  s\   t | t |krtdt|}td|}| j}|j}t||| j|jd}t| || jdS )zl
        Add a delta of a TimedeltaIndex

        Returns
        -------
        Same type as self
        rZ  rb   r[  r   )	r   r   rX   r   r   rN   r  r   ry   )ru   r   r\  r]  r^  rk   rk   rl   _add_timedelta_arraylike  s    
   z/DatetimeLikeArrayMixin._add_timedelta_arraylikec                 C  st   t | j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 rA  zTimedeltaArray | DatetimeArrayr   NrH  )rA   ry   r   r   rg   r   r   r   rg  r   r   rh  r   r   rp   rL  ru   r   rk   rk   rl   _add_nat  s    


zDatetimeLikeArrayMixin._add_natc                 C  s&   t j| jt jd}|t |dS )z+
        Subtract pd.NaT from self
        r   rU  )r   rg  r   r   rh  r   r   rl  rk   rk   rl   _sub_nat%  s    
zDatetimeLikeArrayMixin._sub_natc                   s   t  js&td|j dt j td   | t j|j  j	|j	d}t
 fdd|D } jsx|jr j	|j	B }t||< |S )Ncannot subtract z-dtype from ra   r[  c                   s   g | ]} j j| qS rk   r`  r   rt   rk   rl   r   B  s     z<DatetimeLikeArrayMixin._sub_period_array.<locals>.<listcomp>)rA   ry   r   r   rg   r   Z_require_matching_freqrN   r   r  r   rW   r  r   )ru   r   Znew_i8_valuesr^  r2  rk   rt   rl   _sub_period_array4  s"    


   z(DatetimeLikeArrayMixin._sub_period_arrayc              	   C  s   |t jt jfkstt|dkr8| jdkr8|| |d S tjdt| j	 dt
t d | j|jkstt| j|jft * tjdtd || dt|}W 5 Q R X t| }t|d	d
| j}|S )z
        Add or subtract array-like of DateOffset objects

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

        Returns
        -------
        result : same class as self
        r   r   z)Adding/subtracting object-dtype array to z not vectorized.r   r-  )categoryOTr   )r.  addsubrJ  r   r   r   r   r   rg   r1   r5   r   catch_warningsfilterwarningsr   r   r   r   r   r   rY   r   )ru   r   r1  rN  r   rk   rk   rl   _addsub_object_arrayH  s    
 z+DatetimeLikeArrayMixin._addsub_object_array)ru   r  rs   c                 C  s   |dk	r4|| j kr4t|tr$t|}|| }| | S |dksHt| dkrP|  S | j dkrbtd| d || j   }| d || j   }| j||d| j dS )a  
        Shift each value by `periods`.

        Note this is different from ExtensionArray.shift, which
        shifts the *position* of each element, padding the end with
        missing values.

        Parameters
        ----------
        periods : int
            Number of periods to shift by.
        freq : pandas.DateOffset, pandas.Timedelta, or str
            Frequency increment to shift by.
        Nr   zCannot shift with no freqr   r  )r}   r   r   r   r   r~   r0   r"  )ru   r  r}   re  r  r  rk   rk   rl   _time_shiftn  s    

z"DatetimeLikeArrayMixin._time_shift__add__c                 C  s  t |dd }|tkr |  }n8t|tttjfr@| |}nt|t	rX| 
|}n t|ttjfrt| |}nt|trt| jr| |}nt|rt| jst| td| || jj tj}nt|r| |}nvt|r| |tj}n^t|st |r| !|S t"|rTt| js6t| td| || jj tj}nt#S t|tj$rt|jrddl%m&} ||S |S Nry   ra   r   )rb   )'r   r   rm  r   r   r   r   r  rj  r   rf  r   r  rO  r   rC   ry   rd  r   r   rA   r#   r   _addsub_int_array_or_scalarr}   r   r.  rs  rk  r@   rw  r9   r:   rQ  r>   NotImplementedndarrayrI  rb   ru   r   other_dtyper   rb   rk   rk   rl   ry    sH    




 



 	zDatetimeLikeArrayMixin.__add__c                 C  s
   |  |S rz   )ry  rP  rk   rk   rl   __radd__  s    zDatetimeLikeArrayMixin.__radd____sub__c                 C  s  t |dd }|tkr |  }nLt|tttjfrB| | }n*t|t	r\| 
| }nt|ttjfrx| |}nt|rt| jst| td| || jj tj}nt|tr| |}nt|r| | }nt|r| |tj}nvt|s
t |r| !|}nVt|r,| "|}n@t#|rht| jsJt| td| || jj tj}nt$S t|tj%rt|jrddl&m'} ||S |S rz  )(r   r   rn  r   r   r   r   r  rj  r   rf  r   r  rY  r   r   rA   ry   r#   r   r{  r}   r   r.  rt  r   rc  rC   rk  r@   rw  r9   r:   r_  rp  r>   r|  r}  rI  rb   r~  rk   rk   rl   r    sL    




 




 zDatetimeLikeArrayMixin.__sub__c                 C  s   t |dd }t|rZt| jrZt|r4t||  S t|tsRddl	m
} ||}||  S t| jrt|drt|jstdt| j dt|j nNt| jrt|rtdt| j d|j nt| jrtd| } |  | S | |  S )Nry   r   rB  ro  z from rb   )r   r8   rC   ry   r   r   r   r   rd   rI  r`   r   r   r   rg   rA   r   )ru   r   r  r`   rk   rk   rl   __rsub__  s.    




zDatetimeLikeArrayMixin.__rsub__c                 C  s2   | | }|d d  | d d < t | js.|j| _| S rz   rA   ry   r}   r   ru   r   r   rk   rk   rl   __iadd__*  s
    
zDatetimeLikeArrayMixin.__iadd__c                 C  s2   | | }|d d  | d d < t | js.|j| _| S rz   r  r  rk   rk   rl   __isub__3  s
    
zDatetimeLikeArrayMixin.__isub__r   r	  
int | Nonec                K  s   t d| t || j t| jrxtj| j	d||d}|t
krHt
S |	d}|dksd| jdkrn| |S | |S 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.
        rk   M8[ns]r  r   Nr   )nvZvalidate_minvalidate_minmax_axisr   rA   ry   rL   Znanminrp   r   r   r   _from_backing_data_wrap_reduction_resultru   r   r	  r$  r   rk   rk   rl   min?  s     

  


zDatetimeLikeArrayMixin.minc                K  s   t d| t || j t| jrxtj| j	d||d}|t
krH|S |	d}|dksd| jdkrn| |S | |S 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.
        rk   r  r  r   Nr   )r  Zvalidate_maxr  r   rA   ry   rL   Znanmaxrp   r   r   r   r  r  r  rk   rk   rl   max\  s     

  


zDatetimeLikeArrayMixin.max)r	  r   c                C  sD   t | jr tdt| j dtj| j|||  d}| 	||S )an  
        Return the mean value of the Array.

        .. versionadded:: 0.25.0

        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.
        zmean is not implemented for zX since the meaning is ambiguous.  An alternative is obj.to_timestamp(how='start').mean()r   r	  r2  )
rA   ry   r   r   rg   rL   Znanmeanrp   rK   r  )ru   r	  r   r   rk   rk   rl   meany  s    
   zDatetimeLikeArrayMixin.meanc                K  s   t d| |d k	r*t|| jkr*tdt| jr|tj| j	
d||d}|
d}|d ksh| jdkrr| |S | |S tj| j	||d}| ||S )Nrk   z abs(axis) must be less than ndimr  r  r   r   )r  Zvalidate_medianabsr   r   rA   ry   rL   Z	nanmedianrp   r   r   r  r  r  rk   rk   rl   median  s    

  


zDatetimeLikeArrayMixin.median)dropnac                 C  sF   d }|r|   }t| d|d}|| jj}ttj|}| |S )Nr   )r2  )	rK   rP   r   rp   ry   r   r   r}  r  )ru   r  r2  Zi8modesZnpmodesrk   rk   rl   _mode  s    zDatetimeLikeArrayMixin._mode)NNF)F)F)F)N)T).)N)r   )r   )F)F)F)N)T)drg   rh   ri   rj   __annotations__r4   rv   r   propertyr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   classmethodr   r~   r   r   r   r   r   r   r   r   rT   r  rO   rK   r  r  r   r  r}   setterr  r  r  r  r  r"  r)  r*  r,  r3  r^   r4  r5  r6  r7  r8  r9  r:  r;  r<  r=  r>  r?  r   rO  rQ  rY  r_  rc  rd  rf  rj  rk  rm  rn  rp  rw  rx  r\   ry  r  r  r  r  r  r  r  r  r  r  __classcell__rk   rk   r   rl   rd      s"  

   T 
$#>3	 

8 

	
&5 


&&
6
7#	'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)URLr   r   )r   rs   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   )ru   r   r   rk   rk   rl   strftime  s    1zDatelikeOps.strftimeN)rg   rh   ri   rj   r3   r  rk   rk   rk   rl   r    s
   r  aM	  
    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='T')
    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)
    TimelikeOpsTr0  c                      s<  e Zd ZU dZded< dejdfdddd	Zed
d Z	e
ddddZe
ddddZddd fddZdd Zeee jddd5ddZeee jddd6dd Zeee jd!dd7d"d#Zdd$d%d&ddd'd(d)Zdd$d%d&ddd'd*d+Zd,dd-d.Zd/d0 Zd8ddd2 fd3d4Z  ZS )9r0  zK
    Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
    znp.dtype_default_dtypeNFrq   r   c                 C  s  t |dd}t|tr$|jdtd}t|dd }|d k}|tjk	rF|nd }t|t| r|r^n4|d krn|j	}n$|r|j	rt
|}t||j	d\}}|d k	rt|}t||jstd| d|j |j}|j}n|d kr| j}t|tjstd	t|j d
t| j d|jdkr$td|jdkr<|| j}| ||}|dkrhtdt| j d|rv| }|rt
|}tj| ||d || _|d kr|d k	rt| | | d S )NTr   r   Zna_valuer   Fzdtype=z does not match data dtype 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   inferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.)r   ry   )rY   r   rV   to_numpyr   r   r   
no_defaultr   r}   r   validate_inferred_freqrE   r<   ry   r   rp   r  r   r}  r   rg   r   r   _validate_dtyper~   r   r   r   r  )ru   r   ry   r}   r~   r  Zexplicit_none_rk   rk   rl   r     sZ    


zTimelikeOps.__init__c                 C  s   t | d S rz   r{   )r   r   ry   rk   rk   rl   r    s    zTimelikeOps._validate_dtyper   rr   c                 C  s   t | jjS rz   )r   rp   ry   rt   rk   rk   rl   r     s    zTimelikeOps._resor   c                 C  s
   t | jS rz   )dtype_to_unitry   rt   rk   rk   rl   rK    s    zTimelikeOps._unitznp.ufunc)ufuncmethodc                   sV   |t jt jt jfkr@t|dkr@|d | kr@t||| jf|S t j||f||S )Nr   r   )	r   isnanisinfisfiniter   r   rp   r   __array_ufunc__)ru   r  r  inputsr$  r   rk   rl   r    s    

zTimelikeOps.__array_ufunc__c           
      C  s   t | jr@td| } | d }|||||}|j| j||dS | d}ttj|}t	|j
}tt	|| j}t|||}	| j|	td}|| jj}| j|| jdS )Nr`   )	ambiguousnonexistentr   r   r   )r:   ry   r   Ztz_localize_roundr   r   r   r}  r   nanosr   r   r!   r  r   rp   rL  )
ru   r}   rP   r  r  Znaiver   r   r  Z	result_i8rk   rk   rl   r    s"    


  

zTimelikeOps._roundround)r1  raisec                 C  s   |  |tj||S rz   )r  r    ZNEAREST_HALF_EVENru   r}   r  r  rk   rk   rl   r    s    zTimelikeOps.roundfloorc                 C  s   |  |tj||S rz   )r  r    ZMINUS_INFTYr  rk   rk   rl   r    s    zTimelikeOps.floorceilc                 C  s   |  |tj||S rz   )r  r    Z
PLUS_INFTYr  rk   rk   rl   r    s    zTimelikeOps.ceilTr  r  )r   r	  rs   c                C  s   t j| j|||  dS Nr  )rL   Znananyrp   rK   ru   r   r	  rk   rk   rl   r     s    zTimelikeOps.anyc                C  s   t j| j|||  dS r  )rL   Znanallrp   rK   r  rk   rk   rl   r     s    zTimelikeOps.allrw   c                 C  s
   d | _ d S rz   r  rt   rk   rk   rl   r   "  s    zTimelikeOps._maybe_clear_freqc                 C  sJ   |dkr
n.t | dkr"t|tr"n|dks.t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   rJ  r   r  r   r   )ru   r}   Zarrrk   rk   rl   
_with_freq%  s    
zTimelikeOps._with_freqr   )na_sentinelsortc                   sh   | j d k	rZtjt| tjd}|  }|rR| j jdk rR|d d d }|d d d }||fS t j|dS )Nr   r   r   )r  )	r}   r   Zaranger   Zintpr~   r   r   	factorize)ru   r  r  codesZuniquesr   rk   rl   r  E  s    
zTimelikeOps.factorize)r  r  )r  r  )r  r  )r   F)rg   rh   ri   rj   r  r   r  r   r  r  r4   r   rK  r  r  r2   
_round_doc_round_exampler   r  _floor_exampler  _ceil_exampler  r   r   r   r  r  r  rk   rk   r   rl   r0    s0   
C
"  rq   r   )r~   cls_namec                 C  s   t | ds0t| dkr t| } t| } d}n(t| trLtd| dnt| dd} t| t	rv| j
dtd	} 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   r   r   r   r   rI   r   rY   rV   r  r   r}  rU   rH   r   Ztaker  r   Z_values)r|   r~   r  rk   rk   rl   !ensure_arraylike_for_datetimelikeZ  s"    




r  rw   )r  rs   c                 C  s   d S rz   rk   r  rk   rk   rl   validate_periodsx  s    r  floatr   c                 C  s   d S rz   rk   r  rk   rk   rl   r  }  s    zfloat | Noner  c                 C  s8   | dk	r4t | rt| } nt | s4t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
    Nzperiods must be a number, got )r   Zis_floatr   r   r   r  rk   rk   rl   r    s    


ztuple[BaseOffset | None, bool]rr   c                 C  sH   |dk	r@| dk	r0| |kr0t d| d| j n| dkr<|} d}| |f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
    freq_infer : bool

    Returns
    -------
    freq : DateOffset or None
    freq_infer : bool

    Notes
    -----
    We assume at this point that `maybe_infer_freq` has been called, so
    `freq` is either a DateOffset object or None.
    Nr  r   F)r   r  )r}   r  
freq_inferrk   rk   rl   r    s    r  c                 C  s0   d}t | ts(| dkr t| } nd}d} | |fS )a  
    Comparing a DateOffset to the string "infer" raises, so we need to
    be careful about comparisons.  Make a dummy variable `freq_infer` to
    signify the case where the given freq is "infer" and set freq to None
    to avoid comparison trouble later on.

    Parameters
    ----------
    freq : {DateOffset, None, str}

    Returns
    -------
    freq : {DateOffset, None}
    freq_infer : bool
        Whether we should inherit the freq of passed data.
    Fr  TN)r   r   r   )r}   r  rk   rk   rl   maybe_infer_freq  s    

r  zDatetimeTZDtype | np.dtyperx   c                 C  s   t | tr| 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   rF   rG  r   Zdatetime_datar   rk   rk   rl   r    s    
r  )
__future__r   r   r   r.  typingr   r   r   r   r	   r
   r   r   r   r   r   Z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   Zpandas._libs.tslibs.fieldsr    r!   Zpandas._libs.tslibs.np_datetimer"   Zpandas._libs.tslibs.timestampsr#   Zpandas._typingr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   Zpandas.compat.numpyr.   r  Zpandas.errorsr/   r0   r1   Zpandas.util._decoratorsr2   r3   r4   Zpandas.util._exceptionsr5   Zpandas.core.dtypes.commonr6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   Zpandas.core.dtypes.dtypesrF   rG   Zpandas.core.dtypes.genericrH   rI   Zpandas.core.dtypes.missingrJ   rK   Zpandas.corerL   rM   Zpandas.core.algorithmsrN   rO   rP   rQ   Zpandas.core.arraylikerR   Zpandas.core.arrays._mixinsrS   rT   Zpandas.core.arrays.baserU   Zpandas.core.arrays.integerrV   Zpandas.core.commoncorecommonr   Zpandas.core.constructionrW   r   rX   rY   Zpandas.core.indexersrZ   r[   Zpandas.core.ops.commonr\   Zpandas.core.ops.invalidr]   r^   Zpandas.tseriesr_   rI  r`   ra   rb   r   rc   	Exceptionrf   rd   r  r  r  r  r  r  r0  r  r  r  r  r  rk   rk   rk   rl   <module>   s   0@0H	            ':? O%