U
    MZf-                    @  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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+ d d	l,m-Z-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@mAZA d dlBmCZD d dlEmFZFmGZGmHZH d dlImJZJmKZKmLZL d dlMmNZN d dlOmPZPmQZQmRZRmSZSmTZTmUZUmVZVmWZWmXZXmYZYmZZZm[Z[m\Z\m]Z]m^Z^ d dl_m`Z`maZa d dlbmcZcmdZd d dlemfZfmgZg d dlhmiZimjZjmkZk d dllmmZmmnZnmoZo d dlpmqZq d dlrmsZs d dltmuZumvZv d dlwmxZx d dlymzZz d dl{m|Z| d dl}m~  mZ d dlmZmZmZ d dlmZmZ d dlmZ d d lmZmZ d d!lmZ erd d"lmZmZmZ ee6ef Zed#d$d%Zd&d&d'd(d)ZG d*d$ d$eseuZG d+d, d,eZd-Zd.Zd/Zd0Zed1d2d%ZG d3d2 d2eZd4d5d6d7d8Zed9d9d:d;d<Zed=d>d:d?d<Zd@dAd:dBd<ZdCdDdEdFZdGdH ZdId5dJdKdLZdS )M    )annotations)datetime	timedelta)wrapsN)TYPE_CHECKINGAnyCallableIteratorLiteralSequenceTypeVarUnioncastfinaloverload)algoslib)NDArrayBacked)
BaseOffsetIncompatibleFrequencyNaTNaTTypePeriod
ResolutionTick	Timedelta	Timestampastype_overflowsafe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AxisIntDatetimeLikeScalarDtypeDtypeObjFNpDtypePositionalIndexer2DPositionalIndexerTupleScalarIndexerSequenceIndexerTimeAmbiguousTimeNonexistentnpt)function)AbstractMethodErrorInvalidComparison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pandas_dtype)DatetimeTZDtypeExtensionDtype)ABCCategoricalABCMultiIndex)is_valid_na_for_dtypeisna)
algorithmsnanopsops)checked_add_with_arrisin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)DatetimeArrayPeriodArrayTimedeltaArrayDatetimeLikeArrayTDatetimeLikeArrayMixin)boundr-   )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                   sj   t | js | f||S | d} |f||}|tkr@tS t|trV| |jS |d}| |S )NzM8[ns]i8)	rI   dtypeviewr   
isinstancer   	_box_func_value_from_backing_data)selfargskwargsarrresultZres_i8ro    C/tmp/pip-unpacked-wheel-nbcvw55c/pandas/core/arrays/datetimelike.pynew_meth   s    



z"_period_dispatch.<locals>.new_meth)r   r   r-   )ro   r   r~   r}   r   _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<Zed=dd>d?d@ZedAdBdAdCdDd@ZdAdEdFdG fdHd@Zd
ddIdJZdKdLddM fdNdOZdddPdQZdddS fdTdUZedAdAdVdWdXZedYdZd:d[dXZed\d]d:d^dXZeddd`d:dadXZddd`d: fdbdXZeddddedfdAdg fdhdiZddAddAdk fdldmZdndo ZddRdpdddpdqdrZddddsdtduZ dddvdwdxZ!dydz Z"e#d{dd|d}Z$e%d~d 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ddZ-eddddZ.eddddZ/eddddZ0eddddZ1eddddZ2eddddZ3dd Z4e5dZ6e5dZ7e5dZ8e5dZ9e5dZ:e5dZ;e5dZ<e5dZ=e5dZ>e5dZ?e5dZ@e5dZAe#ddddZBe#d
dddZCe#dZdddZDe#dZdZd"ddZEe#ddddZFe#dZdddZGe#dd]d"ddZHe#ddd"ddZIdd ZJddÄ ZKd]dddńZLe#ddddȄZMe#ddʄ ZNe#dd̄ ZOe#dd2d"ddτZPe#d2dddфZQdRdҜdddӜddՄZReSdփdd؄ ZTddڄ ZUeSdۃdd݄ ZVdd߄ ZWdAdAdVddZXdAdAdVddZYeZdAdddAd fddZ[eZddRddddddZ\eZddRddddddZ]dRdcddddddZ^eZddRddddddZ_d ddddZ`  ZaS (  rm   z
    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_scalarsz
np.ndarray_ndarrayzBaseOffset | Nonefreqboolrp   c                 C  s   dS )NTr~   rx   r~   r~   r   _can_hold_na   s    z#DatetimeLikeArrayMixin._can_hold_naNFzDtype | NoneNone)rr   copyrp   c                 C  s   t | d S Nr7   )rx   datarr   r   r   r~   r~   r   __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   r~   r~   r   _scalar_type   s    	z#DatetimeLikeArrayMixin._scalar_typestrDTScalarOrNaT)valuerp   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   rx   r   r~   r~   r   _scalar_from_string   s    z*DatetimeLikeArrayMixin._scalar_from_stringz)np.int64 | np.datetime64 | np.timedelta64c                 C  s   t | dS )ad  
        Unbox the integer value of a scalar `value`.

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

        Returns
        -------
        int

        Examples
        --------
        >>> self._unbox_scalar(Timedelta("10s"))  # doctest: +SKIP
        10000000000
        Nr   r   r~   r~   r   _unbox_scalar   s    z$DatetimeLikeArrayMixin._unbox_scalar)otherrp   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   rx   r   r~   r~   r   _check_compatible_with  s    z-DatetimeLikeArrayMixin._check_compatible_withc                 C  s   t | dS )zI
        box function to get object from internal representation
        Nr   )rx   xr~   r~   r   ru   !  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_inferru   )rx   valuesr~   r~   r   _box_values'  s    z"DatetimeLikeArrayMixin._box_valuesr	   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 r   r~   ).0nr   r~   r   	<genexpr>/  s     z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>c                 3  s   | ]}  |V  qd S r   )ru   )r   vr   r~   r   r   1  s     )ndimrangelenasi8r   r~   r   r   __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.
        rq   )r   rs   r   r~   r~   r   r   3  s    zDatetimeLikeArrayMixin.asi8r   )na_repdate_formatzstr | floatnpt.NDArray[np.object_])r   rp   c                C  s   t | dS )z|
        Helper method for astype when converting to strings.

        Returns
        -------
        ndarray[str]
        Nr   )rx   r   r   r~   r~   r   _format_native_typesC  s    
z+DatetimeLikeArrayMixin._format_native_types)boxedc                 C  s   dj S )Nz'{}')format)rx   r   r~   r~   r   
_formatterO  s    z!DatetimeLikeArrayMixin._formatterzNpDtype | Nonerr   rp   c                 C  s    t |rtjt| tdS | jS )Nrr   )rH   npr`   listobjectr   rx   rr   r~   r~   r   	__array__V  s    z DatetimeLikeArrayMixin.__array__r1   )itemrp   c                 C  s   d S r   r~   rx   r   r~   r~   r   __getitem__\  s    z"DatetimeLikeArrayMixin.__getitem__rl   z(SequenceIndexer | PositionalIndexerTuple)rx   r   rp   c                 C  s   d S r   r~   r   r~   r~   r   r   `  s    r/   z"DatetimeLikeArrayT | DTScalarOrNaT)rx   keyrp   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_scalarrl   _get_getitem_freq_freq)rx   r   r|   	__class__r~   r   r   g  s    
 


c                 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)rI   rr   r   r   rc   rt   slicestepEllipsiscomZis_bool_indexerr   Zmaybe_booleans_to_slicers   r   Zuint8r   )rx   r   Z	is_periodr   Znew_keyr~   r~   r   r   |  s$    






z(DatetimeLikeArrayMixin._get_getitem_freqz,int | Sequence[int] | Sequence[bool] | slicezNaTType | Any | Sequence[Any])r   r   rp   c                   s.   t ||| }t || |r"d S |   d S r   )rd   r   __setitem___maybe_clear_freq)rx   r   r   Zno_opr   r~   r   r     s
    z"DatetimeLikeArrayMixin.__setitem__c                 C  s   d S r   r~   r   r~   r~   r   r     s    z(DatetimeLikeArrayMixin._maybe_clear_freqTr   c                   s4  t |}t|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 t|r| j}|tjkrtd	| j d
| d|r| }|S t| rt| j|rt|r"dt| j d| }t|ntj| |dS d S )NMri   	timestamp)tzboxZresomT)r   r   zConverting from z to z? is not supported. Do obj.astype('int64').astype(dtype) insteadzCannot cast z
 to dtype r   ) rL   rH   rr   kindr   r   r!   r   _cresor"   r   r   ravelreshapeshapert   rN   r   astyperJ   r   rF   r   int64	TypeErrorr   rC   rD   rE   type__name__asarray)rx   rr   r   Zi8dataZ	convertedr   msgr   r~   r   r     sJ    




zDatetimeLikeArrayMixin.astype)rx   rp   c                 C  s   d S r   r~   r   r~   r~   r   rs     s    zDatetimeLikeArrayMixin.viewzLiteral['M8[ns]']ri   c                 C  s   d S r   r~   r   r~   r~   r   rs     s    zLiteral['m8[ns]']rk   c                 C  s   d S r   r~   r   r~   r~   r   rs     s    .r(   c                 C  s   d S r   r~   r   r~   r~   r   rs     s    c                   s   t  |S r   )r   rs   r   r   r~   r   rs     s    r   type[DatetimeLikeArrayT]zSequence[DatetimeLikeArrayT]r)   )cls	to_concataxisrp   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 r~   )r   r   r   r~   r~   r   
<listcomp>  s      z<DatetimeLikeArrayMixin._concat_same_type.<locals>.<listcomp>c                 3  s   | ]}|j  j kV  qd S r   r   r   objr~   r   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   r~   r   r     s     )r   _concat_same_typerr   rI   r   allzipr   )r   r   r   new_objrr   new_freqpairsr   r   r   r     s     z(DatetimeLikeArrayMixin._concat_same_typeC)rx   orderrp   c                   s   t  j|d}| j|_|S )N)r   )r   r   r   r   )rx   r   r   r   r~   r   r     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_objectrr   )rt   r   r   
ValueErrorr   r8   r   r   r   r   r   rG   r   _validate_listlikerH   getattr)rx   r   errr~   r~   r   _validate_comparison_value)  s.    



z1DatetimeLikeArrayMixin._validate_comparison_value)allow_listlike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 | |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)rt   r   r   r   r   _validation_error_messager   rQ   rr   r   rR   r   r   )rx   r   r   r   r   r   r~   r~   r   _validate_scalarM  s(    

z'DatetimeLikeArrayMixin._validate_scalar)r   rp   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   r   r   )rx   r   r   r   r~   r~   r   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   rr   TZextract_numpy)rt   r   r   r   _from_sequencerr   hasattrr   r   infer_dtyper   r   r   r   rb   pd_arrayr>   r?   rD   
categoriesZ_internal_get_valuesrH   r   )rx   r   r   r   r~   r~   r   r     s>    
z)DatetimeLikeArrayMixin._validate_listlikec                 C  s,   t |r| |}n| j|ddS | |S )NT)r   )rG   r   r   _unboxr   r~   r~   r   _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   r~   r~   r   r     s
    

zDatetimeLikeArrayMixin._unboxc                 C  s   ddl m} || |jS )Nr   )Index)Zpandasr   mapr`   )rx   Zmapperr   r~   r~   r   r     s    zDatetimeLikeArrayMixin.mapznpt.NDArray[np.bool_]c              	   C  sD  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 | jjdk rtd| } || j}z| | W n* ttfk
r4   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]
        rr   )fiucr   r   timedelta64r   
datetime64dateZperiodFskipnastringmixedr   r   DatetimeArray | TimedeltaArray)r   r   r   rr   r   zerosr   r   rt   r   r   r   r   rW   r   r   r   r   as_unitunitr   r   r   )rx   r   Z	inferableinferredr~   r~   r   rW     s@    



zDatetimeLikeArrayMixin.isinc                 C  s   | j S r   )_isnanr   r~   r~   r   rR   7  s    zDatetimeLikeArrayMixin.isnac                 C  s
   | j tkS )z-
        return if each value is nan
        )r   r    r   r~   r~   r   r  :  s    zDatetimeLikeArrayMixin._isnanc                 C  s   t | j S )zJ
        return if I have any nans; enables various perf speedups
        )r   r  anyr   r~   r~   r   _hasnaA  s    zDatetimeLikeArrayMixin._hasna)r|   rp   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  )rx   r|   
fill_valuer   r~   r~   r   _maybe_mask_resultsH  s    
z*DatetimeLikeArrayMixin._maybe_mask_resultsz
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   freqstrr   r~   r~   r   r  f  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   rh   Z
infer_freqr   r   r~   r~   r   inferred_freqo  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 r   )r  r   Zget_reso_from_freqstrKeyError)rx   r  r~   r~   r   _resolution_obj}  s    z&DatetimeLikeArrayMixin._resolution_objc                 C  s   | j jS )zO
        Returns day, hour, minute, second, millisecond or microsecond
        )r  attrnamer   r~   r~   r   
resolution  s    z!DatetimeLikeArrayMixin.resolutionc                 C  s   t j| jddd S )NTZtimeliker   r   Zis_monotonicr   r   r~   r~   r   _is_monotonic_increasing  s    z/DatetimeLikeArrayMixin._is_monotonic_increasingc                 C  s   t j| jddd S )NTr  r   r   r   r~   r~   r   _is_monotonic_decreasing  s    z/DatetimeLikeArrayMixin._is_monotonic_decreasingc                 C  s   t t| jd| jkS )NK)r   rX   r   r   sizer   r~   r~   r   
_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sxtt| } | j|jkrxt|t| sdz|j| jdd}W n0 tk
r`   t	 |j!}t"| j#|| Y S X n|j#}t"| j#||S | $|}|| j#%d	|%d	}t&|}| j'|B }|( r|tjk}	t	)|||	 |S )
Nr   r   rr   ignore)r   r   FZround_okrq   )*r   r   r   r   r   r   r8   rf   rH   r   ZerrstaterU   Zcomp_method_OBJECT_ARRAYr   r   r   r   operatorneZonesr   r  rI   rr   r   TimelikeOpsr   rt   r   r  r  r   r`   Zasm8r&   r   r   rs   rR   r  r  r  )
rx   r   oprr   r|   Z	other_arrZ
other_valso_maskmaskZ
nat_resultr~   r~   r   _cmp_method  sV      

  



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 )zR
        Get the int64 values and b_mask to pass to checked_add_with_arr.
        N)rt   r   ordinalr   r   rv   r  r   )rx   r   Zi8valuesr-  r~   r~   r   _get_i8_values_and_mask  s    
z.DatetimeLikeArrayMixin._get_i8_values_and_maskc                 C  s4   t | jr| jS t|sdS t| jtr0| jS dS )zP
        Check if we can preserve self.freq in addition or subtraction.
        N)rI   rr   r   r   r   rt   r   r   r~   r~   r   _get_arithmetic_result_freq  s    

z2DatetimeLikeArrayMixin._get_arithmetic_result_freqc           
      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|r| jt
 d| j d }|j||jd	S t|}| |\} }td| } | |\}}t| j|| j|d
}|d| j d}||j| jd}|d| j d}| |}	|j|||	dS )Ncannot add  and rk   r   ri   )tz_to_dtypezM8[]r   Zarr_maskZb_maskr   r  rr   r   )rK   rr   r   r   r   r   pandas.core.arraysri   Zpandas.core.arrays.datetimesrA  r   AssertionErrorrR   r   Zto_datetime64r   r  _simple_newr   _ensure_matching_resosr<  rV   r   r  rs   r   r=  )
rx   r   ri   rA  r|   other_i8r,  
res_valuesrr   r   r~   r~   r   _add_datetimelike_scalar  s4    


   
z/DatetimeLikeArrayMixin._add_datetimelike_scalarc                 C  s2   t | js*tdt| j dt|j ||  S )Nr>  r?  )rK   rr   r   r   r   r   r~   r~   r   _add_datetime_arraylike1  s
    
z.DatetimeLikeArrayMixin._add_datetime_arraylikezdatetime | np.datetime64)r   c                 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 ri   )rr   r   r   r   r   r   rR   r   r   rI  _sub_datetimelike)rx   r   tsr~   r~   r   _sub_datetimelike_scalar;  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   rN  $cannot add indices of unequal lengthri   )
rr   r   r   r   r   r   r   r   rI  rO  r   r~   r~   r   _sub_datetime_arraylikeL  s    
z.DatetimeLikeArrayMixin._sub_datetime_arraylikezTimestamp | DatetimeArrayc           
   
   C  s   t d| } ddlm} z| | W n@ tk
rd } z"t|dd}t|||W 5 d }~X Y nX | |\}}t	| j
| | j|d}|d| j d}| |}	|j||j|	d	S )
Nri   r   rk   comparesubtractrC  timedelta64[rB  rE  )r   rF  rk   Z_assert_tzawareness_compatr   r   replacer   r<  rV   r   r  rs   r  r=  rH  rr   )
rx   r   rk   r   Znew_messagerJ  r,  rK  Zres_m8r   r~   r~   r   rO  Y  s"    
    
z(DatetimeLikeArrayMixin._sub_datetimeliker   rj   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   )rj   r   )rK   rr   r   r   r   Zpandas.core.arrays.periodrj   r   Zbroadcast_tor;  r   r   )rx   r   rj   Zi8valsZparrr~   r~   r   _add_periodn  s    
z"DatetimeLikeArrayMixin._add_periodc                 C  s   t | d S r   r   )rx   offsetr~   r~   r   _add_offsetz  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
        rq   r   r  )rR   r   emptyr   rs   r   rr   fillr    r   rH  r   r   rI  _add_timedeltalike)rx   r   
new_valuesr~   r~   r   _add_timedeltalike_scalar}  s    

z0DatetimeLikeArrayMixin._add_timedeltalike_scalarc                 C  s:   t | t |krtdtd| } | |\} }| |S )zl
        Add a delta of a TimedeltaIndex

        Returns
        -------
        Same type as self
        rR  r  )r   r   r   rI  r^  r   r~   r~   r   _add_timedelta_arraylike  s
    

z/DatetimeLikeArrayMixin._add_timedelta_arraylikezTimedelta | TimedeltaArrayc                 C  sZ   t d| } | |\}}t| j|| j|d}|| jj}| |}t	| j
|| j|dS )Nr  rC  rE  )r   r<  rV   r   r  rs   r   rr   r=  r   rH  )rx   r   rJ  r,  r_  rK  r   r~   r~   r   r^    s    
   
z)DatetimeLikeArrayMixin._add_timedeltalikec                 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 r?  zTimedeltaArray | DatetimeArrayr   NrE  )rI   rr   r   r   r   r   r   r   r\  r   r   r]  r    rs   r   rH  rx   r|   r~   r~   r   _add_nat  s    


zDatetimeLikeArrayMixin._add_natc                 C  sT   t j| jt jd}|t | jjdkrFtd| } |	d| j
 dS |	dS dS )z+
        Subtract pd.NaT from self
        r   r  zDatetimeArray| TimedeltaArrayrW  rB  ztimedelta64[ns]N)r   r\  r   r   r]  r    rr   r   r   rs   r  rb  r~   r~   r   _sub_nat  s    

zDatetimeLikeArrayMixin._sub_natzPeriod | PeriodArrayc                   s   t  js*tdt|j dt j td   |  |\}}t j	|  j
|d}t fdd|D }|d kr j
}n
 j
|B }t||< |S )Ncannot subtract  from rj   rC  c                   s   g | ]} j j| qS r~   )r   baser   r   r~   r   r     s     z:DatetimeLikeArrayMixin._sub_periodlike.<locals>.<listcomp>)rI   rr   r   r   r   r   r   r<  rV   r   r  r   r`   r   )rx   r   rJ  r,  Znew_i8_dataZnew_datar-  r~   r   r   _sub_periodlike  s&    


   
z&DatetimeLikeArrayMixin._sub_periodlikec                 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|| 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.)
stacklevelO)r(  addsubrG  r   r   warningswarnr   r   r9   r=   r   r   r   r   )rx   r   r+  rK  r~   r~   r   _addsub_object_array  s    z+DatetimeLikeArrayMixin._addsub_object_arrayr  )namer	  c                K  sX   |dkr t d| dt|  tt|}||  fd|i|}t| j|d | jdS )N>   cummaxcumminzAccumulation z not supported for r	  )r   rr   )r   r   r   rY   r   rH  rr   )rx   rp  r	  rz   r+  r|   r~   r~   r   _accumulate  s    
  z"DatetimeLikeArrayMixin._accumulate__add__c                 C  s  t |dd }t|}|tkr(|  }nBt|tttjfrH| 	|}n"t|t
r`| |}n
t|ttjfr|| |}nt|trt| jr| |}nt|rt| jst| td| }|||jj tj}nt|r| |}n|t|r| |tj}nbt |st!|r&| "|S t#|rft| jsDt| td| }|||jj tj}nt$S t|tj%rt|jrddl&m'} ||S |S Nrr   rj   r   rT  )(r   ra   r   rc  rt   r   r   r   r  r`  r   r[  r   r  rL  r   rK   rr   rY  r   
is_integerrI   r'   r   _addsub_int_array_or_scalarr   r   r(  rk  ra  rH   ro  rA   rB   rM  rF   NotImplementedndarrayrF  rk   rx   r   other_dtyper|   r   rk   r~   r~   r   rt  !  sB    







zDatetimeLikeArrayMixin.__add__c                 C  s
   |  |S r   )rt  r   r~   r~   r   __radd__W  s    zDatetimeLikeArrayMixin.__radd____sub__c                 C  s  t |dd }t|}|tkr(|  }nVt|tttjfrJ| 	| }n4t|t
rd| | }nt|ttjfr| |}nt|rt| jst| td| }|||jj tj}nt|tr| |}nt|r| | }nt|r| |tj}nzt |st!|r$| "|}nZt|r:| |}nDt#|rzt| jsXt| td| }|||jj tj}nt$S t|tj%rt|jrddl&m'} ||S |S ru  )(r   ra   r   rd  rt   r   r   r   r  r`  r   r[  r   r  rQ  r   rv  rI   rr   r'   r   rw  r   r   r(  rl  r   rh  rK   ra  rH   ro  rA   rB   rS  rF   rx  ry  rF  rk   rz  r~   r~   r   r}  [  sF    








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 )Nrr   r   r@  re  rf  rk   )r   r@   rK   rr   r   r   r   rt   rm   rF  ri   r   r   r   r   rI   r   )rx   r   r{  ri   r~   r~   r   __rsub__  s.    




zDatetimeLikeArrayMixin.__rsub__c                 C  s2   | | }|d d  | d d < t | js.|j| _| S r   rI   rr   r   r   rx   r   r|   r~   r~   r   __iadd__  s
    
zDatetimeLikeArrayMixin.__iadd__c                 C  s2   | | }|d d  | d d < t | js.|j| _| S r   r  r  r~   r~   r   __isub__  s
    
zDatetimeLikeArrayMixin.__isub__znpt.NDArray[np.float64])rx   qsinterpolationrp   c                   s   t  j||dS )N)r  r  )r   	_quantile)rx   r  r  r   r~   r   r    s    z DatetimeLikeArrayMixin._quantiler   r	  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.
        r~   r  )nvZvalidate_minvalidate_minmax_axisr   rT   Znanminr   _wrap_reduction_resultrx   r   r	  rz   r|   r~   r~   r   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.
        r~   r  )r  Zvalidate_maxr  r   rT   Znanmaxr   r  r  r~   r~   r   max  s    zDatetimeLikeArrayMixin.max)r	  r   c                C  sD   t | jr tdt| j dtj| j|||  d}| 	||S )aL  
        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.
        zmean is not implemented for zX since the meaning is ambiguous.  An alternative is obj.to_timestamp(how='start').mean()r   r	  r-  )
rI   rr   r   r   r   rT   Znanmeanr   rR   r  )rx   r	  r   r|   r~   r~   r   mean  s    
   zDatetimeLikeArrayMixin.meanc                K  sH   t d| |d k	r*t|| jkr*tdtj| j||d}| ||S )Nr~   z abs(axis) must be less than ndimr  )	r  Zvalidate_medianabsr   r   rT   Z	nanmedianr   r  r  r~   r~   r   median  s
    zDatetimeLikeArrayMixin.median)dropnac                 C  sH   d }|r|   }tj| d|d}|| jj}ttj|}| 	|S )Nrq   )r-  )
rR   rS   moders   r   rr   r   r   ry  rw   )rx   r  r-  Zi8modesZnpmodesr~   r~   r   _mode$  s    zDatetimeLikeArrayMixin._mode)NNF)F)N)T).)N)r   )r   )F)F)T)br   
__module____qualname____doc____annotations__r<   r   r   propertyr   r   r   r   ru   r   r   r   r   r   r   r   r   r   r   r   r   rs   classmethodr   r   r   r   r   r   r   r   r   r\   r   rW   rR   r  r  r    r  r  r  r  r  r!  r"  r%  r.  rg   r/  r0  r1  r2  r3  r4  r5  r6  r7  r8  r9  r:  r<  r=  rL  rM  rQ  rS  rO  rY  r[  r`  ra  r^  rc  rd  rh  ro  rs  re   rt  r|  r}  r~  r  r  r   r  r  r  r  r  r  __classcell__r~   r~   r   r   rm      s   
     
 6 
(;3

< 	
<#	

#
5
5#	%	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   rp   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   )rx   r   r|   r~   r~   r   strftime4  s    1zDatelikeOps.strftimeN)r   r  r  r  r;   r  r~   r~   r~   r   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)
    TimelikeOpsTr*  c                      s  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 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!Zd"d# Zd$dd% fd&d'Zd(d) Zeee jd*d+dGd-d.d/d0d1Zeee jd2d+dHd-d.d/d3d4Zeee jd5d+dId-d.d/d6d7Zdd8d9d:ddd;d<d=Zdd8d9d:ddd;d>d?Z ddd@dAZ!dBdC Z"dJdddD fdEdFZ#  Z$S )Kr*  zK
    Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
    znp.dtype_default_dtypeNFr   r   )r   rp   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}n0|d krt|tjr|jjd	kr|j}n| j}t|tjs2td
t|j dt| j d|jdkrFtd|jdkr^|| j}| ||}|dkrtdt| j d|r| }|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Mmz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.rq   inferz#Frequency inference not allowed in z$.__init__. Use 'pd.array()' instead.)r   rr   )rb   rt   r_   to_numpyr    r   r   
no_defaultr   r   r#   validate_inferred_freqrL   rD   rr   r   r   r   ry  r   r  r   r   r   rs   _validate_dtyper   r   r   r   _validate_frequency)rx   r   rr   r   r   r  Zexplicit_none_r~   r~   r   r     s^    



zTimelikeOps.__init__c                 C  s   t | d S r   r   )r   r   rr   r~   r~   r   r  L  s    zTimelikeOps._validate_dtypec                 C  s   | j S )zK
        Return the frequency object if it is set, otherwise None.
        r   r   r~   r~   r   r   P  s    zTimelikeOps.freqr   c                 C  s8   |d k	r.t |}| | | | jdkr.td|| _d S )Nr   zCannot set freq with ndim > 1)r#   r  r   r   r   r   r~   r~   r   r   W  s    
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 nJ t	k
r } z,dt
|kr~|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   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   r   )r   indexr   rz   r  Zon_freqr   r~   r~   r   r  b  s.    zTimelikeOps._validate_frequencyr   rl   )r   rp   c                 O  s   t | d S r   r   )r   r  r  r  r   ry   rz   r~   r~   r   r    s    zTimelikeOps._generate_rangeintc                 C  s   t | jjS r   )r   r   rr   r   r~   r~   r   r     s    zTimelikeOps._cresor   c                 C  s
   t | jS r   )dtype_to_unitrr   r   r~   r~   r   r    s    zTimelikeOps.unitr  )rx   r  rp   c                 C  s~   |dkrt dt| jj d| d}t| j|d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'z8[rB  Tr'  ri   rD  rE  )r   r   rr   r   r   r   rt   r   r   rM   r   rH  r   )rx   r  rr   r_  Z	new_dtyper   r~   r~   r   r    s      zTimelikeOps.as_unitc                 C  s:   | j |j kr2| j |j k r&| |j} n|| j}| |fS r   )r   r  r  r   r~   r~   r   rI    s
    z"TimelikeOps._ensure_matching_resosz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   r   r   __array_ufunc__)rx   r  r  inputsrz   r   r~   r   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|| j}	|	dkr|  S t|||	}
| j|
td}|| jj}| j|| jdS )Nri   	ambiguousnonexistentrq   r   r  r   )rB   rr   r   Ztz_localize_roundr   rs   r   ry  r#   nanosr   r   r   r%   r  r    r   rH  )rx   r   r  r  r  Znaiver|   r   rZ  r  Z	result_i8r~   r~   r   r    s(    


  
zTimelikeOps._roundround)r+  raiser3   r4   r  c                 C  s   |  |tj||S r   )r  r$   ZNEAREST_HALF_EVENrx   r   r  r  r~   r~   r   r    s    zTimelikeOps.roundfloorc                 C  s   |  |tj||S r   )r  r$   ZMINUS_INFTYr  r~   r~   r   r    s    zTimelikeOps.floorceilc                 C  s   |  |tj||S r   )r  r$   Z
PLUS_INFTYr  r~   r~   r   r    s    zTimelikeOps.ceilTr  r  )r   r	  rp   c                C  s   t j| j|||  dS Nr  )rT   Znananyr   rR   rx   r   r	  r~   r~   r   r    s    zTimelikeOps.anyc                C  s   t j| j|||  dS r  )rT   Znanallr   rR   r  r~   r~   r   r     s    zTimelikeOps.allc                 C  s
   d | _ d S r   r  r   r~   r~   r   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   rt   r   rG  r#   r  rs   r   )rx   r   r{   r~   r~   r   
_with_freq  s    
zTimelikeOps._with_freq)use_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)rx   r  r  codesZuniquesr   r~   r   r  /  s    
zTimelikeOps.factorize)r  r  )r  r  )r  r  )TF)%r   r  r  r  r  r   r  r   r  r  r  r   setterr  r  r<   r   r  r  rI  r  r  r:   
_round_doc_round_exampler   r  _floor_exampler  _ceil_exampler  r  r   r   r  r  r  r~   r~   r   r   r*    sV   
  H



*      !  r   r   )r   cls_namec                 C  s   t | ds>t| ttfs.t| dkr.t| } t| } d}n(t| trZtd| dnt	| dd} t| t
st| tr| jjdkr| jd	td
} d}nHt| tjtfrt| trt| } n"t| tr| jj| jtdj} d}| |fS )Nrr   r   FzCannot create a z from a MultiIndex.Tr   iur   r  r  )r   rt   r   tupler   r   r   rP   r   rb   r_   r]   rr   r   r  r    ry  r^   rO   r   Ztaker  r   Z_values)r   r   r  r~   r~   r   !ensure_arraylike_for_datetimelikeD  s0    




 
r  r   )r  rp   c                 C  s   d S r   r~   r  r~   r~   r   validate_periodsf  s    r  zint | floatr  c                 C  s   d S r   r~   r  r~   r~   r   r  k  s    zint | float | Nonez
int | Nonec                 C  sB   | dk	r>t | rt| } nt | s4td|  tt| } | 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  rv  r   r   r  r~   r~   r   r  p  s    



ztuple[BaseOffset | None, bool]r   c                 C  sF   |dk	r>| dk	r.| |kr.t d| d| j | 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_inferr~   r~   r   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)rt   r   r#   )r   r  r~   r~   r   maybe_infer_freq  s    

r  zDatetimeTZDtype | np.dtyper   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   )rt   rM   r  r   Zdatetime_datar   r~   r~   r   r    s    
r  )
__future__r   r   r   	functoolsr   r(  typingr   r   r   r	   r
   r   r   r   r   r   r   rm  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!   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/   r0   r1   r2   r3   r4   r5   Zpandas.compat.numpyr6   r  Zpandas.errorsr7   r8   r9   Zpandas.util._decoratorsr:   r;   r<   Zpandas.util._exceptionsr=   Zpandas.core.dtypes.commonr>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   Zpandas.core.dtypes.dtypesrM   rN   Zpandas.core.dtypes.genericrO   rP   Zpandas.core.dtypes.missingrQ   rR   Zpandas.corerS   rT   rU   Zpandas.core.algorithmsrV   rW   rX   Zpandas.core.array_algosrY   Zpandas.core.arraylikerZ   Zpandas.core.arrays._mixinsr[   r\   Zpandas.core.arrays.arrow.arrayr]   Zpandas.core.arrays.baser^   Zpandas.core.arrays.integerr_   Zpandas.core.commoncorecommonr   Zpandas.core.constructionr`   r   ra   rb   Zpandas.core.indexersrc   rd   Zpandas.core.ops.commonre   Zpandas.core.ops.invalidrf   rg   Zpandas.tseriesrh   rF  ri   rj   rk   r   rl   r   rm   r  r  r  r  r  r  r*  r  r  r  r  r  r~   r~   r~   r   <module>   s   4H@D          ~:?  I"%