o
    5c5                    @  sj  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rRd 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ZdId3d4ZedJd8d9ZedKd<d9ZdLd?d9ZdMdAdBZdCdD ZdNdGdHZdS )O    )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   U/var/www/html/gps/gps/lib/python3.10/site-packages/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dddZddddZedddZ	dddZ
	dddd Z	ddd"d#Zedd$d%Zd&d' Zdd(d)Zd*d+ Zedd-d.Zd/dd0dd2d3Zddd5d6Zddd8d9Zedd<d=Zed dAd=Zd fdEd=ZddGdHZd fdKdLZdMdN Zdd fdQdRZeddSdTZeddWdTZeddZdTZed	d
d]dTZdd
 fd^dTZe	_dd fdfdgZdd fdidjZdkdl Zdmdn Z ddOdOdoddrdsZ!dddtduZ"dddwdxZ#dydz Z$d{d| Z%	ddd~dZ&e'dd Z(dddZ)dddZ*edddZ+edddZ,e-dfdddZ.edd Z/e/j0dddZ/edddZ1edddZ2edddZ3edddZ4edd Z5edddZ6edddZ7edddZ8eddd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ZGeHdddZIeHdddZJeHdddZKeHdd ZLeHdddZMeHdddZNddÄ ZOddń ZPdddȄZQeHddʄ ZReHdd̄ ZSeHddd΄ZTeHdddЄZU	dd ddӄZVeWdԃddք ZXdd؄ ZYeWdكddۄ ZZdd݄ Z[ddd߄Z\dddZ]ddOdd!ddZ^ddOdd!ddZ_dOd_dd"ddZ`ddOdd!ddZa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_scalars
np.ndarray_ndarrayreturnboolc                 C  s   dS )NTrk   selfrk   rk   rl   _can_hold_na      z#DatetimeLikeArrayMixin._can_hold_naNFdtypeDtype | NoneNonec                 C     t | Nr/   )ru   datarx   freqcopyrk   rk   rl   __init__      zDatetimeLikeArrayMixin.__init__type[DatetimeLikeScalar]c                 C  r{   )z
        The scalar associated with this datelike

        * PeriodArray : Period
        * DatetimeArray : Timestamp
        * TimedeltaArray : Timedelta
        r}   rt   rk   rk   rl   _scalar_type   s   	z#DatetimeLikeArrayMixin._scalar_typevaluestrDTScalarOrNaTc                 C  r{   )ay  
        Construct a scalar type from a string.

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

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

        Notes
        -----
        This should call ``self._check_compatible_with`` before
        unboxing the result.
        r}   ru   r   rk   rk   rl   _scalar_from_string   s   z*DatetimeLikeArrayMixin._scalar_from_stringsetitem)np.int64 | np.datetime64 | np.timedelta64c                 C  r{   )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
        r}   )ru   r   r   rk   rk   rl   _unbox_scalar   s   z$DatetimeLikeArrayMixin._unbox_scalarotherc                 C  r{   )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
        r}   ru   r   r   rk   rk   rl   _check_compatible_with   s   z-DatetimeLikeArrayMixin._check_compatible_withc                 C     | j S r|   )rq   rt   rk   rk   rl   _data     zDatetimeLikeArrayMixin._datac                 C  r{   )zI
        box function to get object from internal representation
        r}   )ru   xrk   rk   rl   	_box_func     z DatetimeLikeArrayMixin._box_funcc                 C  s   t j|| jddS )z1
        apply box func to passed values
        F)convert)r   	map_inferr   )ru   valuesrk   rk   rl   _box_values  s   z"DatetimeLikeArrayMixin._box_valuesc                   s8    j dkr fddtt D S  fdd jD S )N   c                 3  s    | ]} | V  qd S r|   rk   ).0nrt   rk   rl   	<genexpr>#  s    z2DatetimeLikeArrayMixin.__iter__.<locals>.<genexpr>c                 3  s    | ]}  |V  qd S r|   )r   )r   vrt   rk   rl   r   %  s    )ndimrangelenasi8rt   rk   rt   rl   __iter__!  s   
zDatetimeLikeArrayMixin.__iter__npt.NDArray[np.int64]c                 C  s   | j dS )z
        Integer representation of the values.

        Returns
        -------
        ndarray
            An ndarray with int64 dtype.
        i8)rq   viewrt   rk   rk   rl   r   '  s   zDatetimeLikeArrayMixin.asi8r   )na_repdate_formatnpt.NDArray[np.object_]c                C  r{   )z|
        Helper method for astype when converting to strings.

        Returns
        -------
        ndarray[str]
        r}   )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  r   z!DatetimeLikeArrayMixin._formatterNpDtype | Nonec                 C  s    t |rtjt| tdS | jS )Nrx   )r@   nprW   listobjectrq   ru   rx   rk   rk   rl   	__array__J  s   z DatetimeLikeArrayMixin.__array__itemr+   c                 C     d S r|   rk   ru   r   rk   rk   rl   __getitem__P  rw   z"DatetimeLikeArrayMixin.__getitem__ru   rc   (SequenceIndexer | PositionalIndexerTuplec                 C  r   r|   rk   r   rk   rk   rl   r   T  s   keyr)   "DatetimeLikeArrayT | DTScalarOrNaTc                   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   


BaseOffset | Nonec                 C  s   t | j}|r| j}|S | jdkrd}|S t| |}d}t|tr8| jdur3|jdur3|j| j }|S | j}|S |tu rA| j}|S t	
|rYt|tj}t|trY| |S |S )z\
        Find the `freq` attribute to assign to the result of a __getitem__ lookup.
        r   N)rA   rx   r   r   rZ   
isinstanceslicestepEllipsiscomis_bool_indexerr   maybe_booleans_to_slicer   r   uint8r   )ru   r   	is_periodr   new_keyrk   rk   rl   r   p  s.   



	


z(DatetimeLikeArrayMixin._get_getitem_freq,int | Sequence[int] | Sequence[bool] | sliceNaTType | Any | Sequence[Any]c                   s.   t ||| }t || |rd S |   d S r|   )r[   r   __setitem___maybe_clear_freq)ru   r   r   no_opr   rk   rl   r     s
   z"DatetimeLikeArrayMixin.__setitem__c                 C  r   r|   rk   rt   rk   rk   rl   r     s   z(DatetimeLikeArrayMixin._maybe_clear_freqTr   c                   s  t |}t|r=| jjdkr$td| } | j}t|| j| jd| j	d}|S | jjdkr1t
| jddS | | j | jS t|trJt j||dS t|rR|  S t|r| j}t|r|d	}|tjkrytjd
| j d| dtt d n/| jdk  rtjd
| j d| dtt d n|tj krtjd
| j d| dtt d |r|! }|S t"|rt#| j|rt$|rdt%| j& d| }t'|tj(| |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@   rx   kindr   r   r   r   r   _resor   rq   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   rx   r   i8data	convertedr   msgr   rk   rl   r     sn   




	
zDatetimeLikeArrayMixin.astypec                 C  r   r|   rk   rt   rk   rk   rl   r     rw   zDatetimeLikeArrayMixin.viewLiteral['M8[ns]']r`   c                 C  r   r|   rk   r   rk   rk   rl   r     rw   Literal['m8[ns]']rb   c                 C  r   r|   rk   r   rk   rk   rl   r     rw   .r$   c                 C  r   r|   rk   r   rk   rk   rl   r   	  rw   c                   s   t  |S r|   )r   r   r   r   rk   rl   r     s   r   clstype[DatetimeLikeArrayT]	to_concatSequence[DatetimeLikeArrayT]axisintc                   s   t  ||}|d   j}d }t|r j}n6|dkrNdd |D } jd urNt fdd|D rNt|d d |dd  }t fdd|D rN j}||_|S )	Nr   c                 S  s   g | ]}t |r|qS rk   )r   r   r   rk   rk   rl   
<listcomp>&      z<DatetimeLikeArrayMixin._concat_same_type.<locals>.<listcomp>c                 3  s    | ]	}|j  j kV  qd S r|   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_typerx   rA   r   allzipr   )r   r   r   new_objrx   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y   t|w t || js$|tu rE| |}z| 	| W |S  t
tfyD } zt||d }~ww t|sMt|t|t| krYtdz| j|dd}| 	| W |S  t
tfy } ztt|dd r{nt||W Y d }~|S d }~ww )NzLengths must matchT)allow_objectrx   )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}n:t|| jr| |}n.| jtu r(t|r(t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   rx   r   r   ro   r   r   r   
is_integer_from_ordinalr   r   r   r   rg   r   r5   _unbox)ru   
fill_valuenew_fillrk   rk   rl   _validate_shift_value^  s    
	z,DatetimeLikeArrayMixin._validate_shift_value)allow_listliker   unboxr  r  c             
   C  s   t || jrnQt |tr+z| |}W nD ty* } z| ||}t||d}~ww t|| jr4t	}n$t
|rB| ||}t|t || jrN| |}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   rx   r   rK   ro   r   )ru   r   r  r   r  r
  r   rk   rk   rl   _validate_scalar}  s,   

z'DatetimeLikeArrayMixin._validate_scalarc                 C  sD   |rd| j j dt|j d}|S 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  sd  t |t| r	|S t |trt|dkrt| jg | jdS t|drS|jtkrSt	|| j
v rSz	t| |}W n ttfyR   |rH| Y S | |d}t|w t|dd}t|}t|dd}t|r}zt| j|| jd}W n	 ty|   Y nw t|jrt|jj| jr| }t|dd}|rt|jr	 |S t| |js| |d}t||S )Nr   r   rx   Textract_numpy)r   r   r   r   _from_sequencerx   hasattrr   r   infer_dtyperm   r  r   r  rY   pd_arrayr6   r7   r<   
categories_internal_get_valuesr@   rn   )ru   r   r  r   rk   rk   rl   r    sD   
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_value6np.int64 | np.datetime64 | np.timedelta64 | np.ndarrayc                 C  s4   t |r| j||d}|S | j||d |j}|S )zZ
        Unbox either a scalar with _unbox_scalar or an instance of our own type.
        r  )r   r   r   r   rq   r   rk   rk   rl   r    s   
zDatetimeLikeArrayMixin._unboxc                 C  s   ddl m} || |jS )Nr   )Index)pandasr"  maprW   )ru   mapperr"  rk   rk   rl   r$  ,  s   zDatetimeLikeArrayMixin.mapnpt.NDArray[np.bool_]c              	   C  s  t |ds
t|}|jjdv rtj| jtdS t|t	| sgg d}|jt
krLtj|dd}||vrL|dkr8nd|v rDt| t
|S tj| jtdS z	t	| |}W n tyf   t| t
| Y S w z| | W n ttfy   tj| jtd Y S w 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]
        rx   )fiucr   )r   timedelta64r   
datetime64dateperiodF)skipnastringmixed)r  r   r   rx   r   zerosr   rs   r   r   r   r   r  rO   r   r  r  r   r   r   )ru   r   	inferableinferredrk   rk   rl   rO   7  s2   


zDatetimeLikeArrayMixin.isinc                 C  r   r|   )_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   r5  r     
zDatetimeLikeArrayMixin._isnanc                 C  s   t | j S )zJ
        return if I have any nans; enables various perf speedups
        )rs   r5  r   rt   rk   rk   rl   _hasnay  s   zDatetimeLikeArrayMixin._hasnar   c                 C  s6   | j r|r
||}|du rtj}t|| j| |S )az  
        Parameters
        ----------
        result : np.ndarray
        fill_value : object, default iNaT
        convert : str, dtype or None

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

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

        This is an internal routine.
        N)r7  r   r   nanputmaskr5  )ru   r   r  r   rk   rk   rl   _maybe_mask_results  s   
z*DatetimeLikeArrayMixin._maybe_mask_resultsc                 C  r   )zK
        Return the frequency object if it is set, otherwise None.
        r   rt   rk   rk   rl   r     s   zDatetimeLikeArrayMixin.freqc                 C  s8   |d u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   


str | Nonec                 C  s   | j du 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  s0   | j dkrdS zt| W S  ty   Y dS w )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_   
infer_freqr  rt   rk   rk   rl   inferred_freq  s   
z$DatetimeLikeArrayMixin.inferred_freqResolution | Nonec                 C  s4   | j }|d u r	d S zt|W S  ty   Y d S w r|   )r>  r   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
        )rD  attrnamert   rk   rk   rl   
resolution  s   z!DatetimeLikeArrayMixin.resolutionc              
   K  s   |j }|jdks||jkrdS z| jd|d dt||d|}t|j|js+tW dS  tyM } zdt	|v r=|td| d|j |d}~ww )am  
        Validate that a frequency is compatible with the values of a given
        Datetime Array/Index or Timedelta Array/Index

        Parameters
        ----------
        index : DatetimeIndex or TimedeltaIndex
            The index on which to determine if the given frequency is valid
        freq : DateOffset
            The frequency to validate
        r   Nstartendperiodsr   z	non-fixedInferred frequency 9 from passed values does not conform to passed frequency rk   )
r@  sizer>  _generate_ranger   r   array_equalr   r  r   )r   indexr   kwargsr4  on_freqerk   rk   rl   r<    s0   z*DatetimeLikeArrayMixin._validate_frequencyc                 O  r{   r|   r}   )r   rH  rI  rJ  r   argsrQ  rk   rk   rl   rN     r   z&DatetimeLikeArrayMixin._generate_rangec                 C     t j| jddd S )NTtimeliker   r   is_monotonicr   rt   rk   rk   rl   _is_monotonic_increasing	     z/DatetimeLikeArrayMixin._is_monotonic_increasingc                 C  rU  )NTrV  r   rX  rt   rk   rk   rl   _is_monotonic_decreasing  r[  z/DatetimeLikeArrayMixin._is_monotonic_decreasingc                 C  s   t t| jd| jkS )NK)r   rQ   r   r   rM  rt   rk   rk   rl   
_is_unique  s   z!DatetimeLikeArrayMixin._is_uniquec           
   	   C  s  | j dkrt|dd | jkr||  | | jS z| |}W n ty1   t| || Y S w t|dd }t|rbt	j
dd t|t	| t|}W d    |S 1 s[w   Y  |S |tu r|tju rut	j| jtd}|S t	j| jtd}|S t| jstt| } | j|jkrt|t| st	|j}n|j}t | j||S | !|}|| j"d|"d}t#|}| j$|B }|% r|tju }	t	&|||	 |S )Nr   r   rx   ignore)r   r   r   )'r   r	  r   r   r   r  rf   r]   r@   r   errstaterM   comp_method_OBJECT_ARRAYr   r   r   r   operatorneonesrs   r2  rA   rx   r   TimelikeOpsr   r   r   rW   asm8rq   r"   r  r   rK   r5  r   r9  )
ru   r   oprx   r   	other_arr
other_valso_maskmask
nat_resultrk   rk   rl   _cmp_method  sL   






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
us,J t|}|t
u rK| jt
 d| j d }|j||jd	S | j|jkrUt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rx   r   )rC   rx   r   r   rg   r   pandas.core.arraysr`   pandas.core.arrays.datetimesr}  r   r   rq   to_datetime64r   _unit_simple_newr   NotImplementedErrorr   rN   r   r5  r   r   r   )ru   r   r`   r}  r   r   rx   
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 )Nrz  r{  )rC   rx   r   r   rg   rX   ru   r   rk   rk   rl   _add_datetime_arraylike{  s   
z.DatetimeLikeArrayMixin._add_datetime_arraylikedatetime | np.datetime64c              
   C  s   | j jdkrtdt| j td| } |tusJ t|}|tu r'| t S z| | W n tyI } zt	|
dd}t|||d }~ww | j}t||j | jd}|dS )Nr   "cannot subtract a datelike from a r`   comparesubtractr  timedelta64[ns])rx   r   r   r   rg   r   r   r   _assert_tzawareness_compatr   replacer   rN   r   r5  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rtdtd| } t|}z| 	| W n tyG } zt
|dd}t|||d }~ww | j}|j}t|| | j|jd}|dS )	Nr   r  $cannot add indices of unequal lengthr`   r  r  r  b_maskr  )rx   r   r   r   rg   r   r  r   rX   r  r   r  r   rN   r5  r   )ru   r   r
  r  self_i8other_i8
new_valuesrk   rk   rl   _sub_datetime_arraylike  s&   

z.DatetimeLikeArrayMixin._sub_datetime_arrayliker   c                   sj   t  jstdt j  | t j|j  j	d}t
 fdd|D } jr3t| j	< |S )Nzcannot subtract Period from a r  c                      g | ]} j j| qS rk   r   baser   rt   rk   rl   r     r   z6DatetimeLikeArrayMixin._sub_period.<locals>.<listcomp>)rA   rx   r   r   rg   r   rN   r   ordinalr5  r   rW   r7  r   )ru   r   new_i8_data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   rx   r   r   rg   pandas.core.arrays.periodra   r   broadcast_tor  r   r   )ru   r   ra   i8valsparrrk   rk   rl   _add_period  s   
z"DatetimeLikeArrayMixin._add_periodc                 C  r{   r|   r}   )ru   offsetrk   rk   rl   _add_offset  r   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sDt| jrG| j}t	| j
|| j|dS )zk
        Add a delta of a timedeltalike

        Returns
        -------
        Same type as self
        r   r   )r   r  Nr  )rK   r   emptyr   r   rq   rx   fillr   r   r  r   r   rN   r   r5  r   r   r   rA   )ru   r   r  incr  rk   rk   rl   _add_timedeltalike_scalar  s   
z0DatetimeLikeArrayMixin._add_timedeltalike_scalar,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
        r  rb   r  r   )	r   r  rX   r   r   rN   r5  r   rx   )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 r{  zTimedeltaArray | DatetimeArrayr   Nr  )rA   rx   r   r   rg   r   r   r   r  r   r   r  r   r   rq   r  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   r  )r   r  r   r   r  r   r   r  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s<|jrF j	|j	B }t||< |S )Ncannot subtract z-dtype from ra   r  c                   r  rk   r  r   rt   rk   rl   r   B  r   z<DatetimeLikeArrayMixin._sub_period_array.<locals>.<listcomp>)rA   rx   r   r   rg   r   _require_matching_freqrN   r   r5  r   rW   r7  r   )ru   r   new_i8_valuesr  rk  rk   rt   rl   _sub_period_array4  s   


z(DatetimeLikeArrayMixin._sub_period_arrayc                 C  s   |t jt jfv s
J t|dkr| jdkr|| |d S tjdt| j dt	t
 d | j|jks:J | j|jft  tjdtd || dt|}W d	   n1 s[w   Y  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ONTr  )rb  addsubr   r   r   r   r   rg   r1   r5   r   catch_warningsfilterwarningsr   r   r   r   r  r   rY   r   )ru   r   rg  r  r   rk   rk   rl   _addsub_object_arrayH  s$   
z+DatetimeLikeArrayMixin._addsub_object_arrayrJ  c                 C  s   |dur|| j krt|trt|}|| }| | S |dks$t| dkr(|  S | j du r1t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   rG  )r   r   r   r   r   r   r0   rN  )ru   rJ  r   r  rH  rI  rk   rk   rl   _time_shiftn  s   

z"DatetimeLikeArrayMixin._time_shift__add__c                 C  sx  t |dd }|tu r|  }nt|tttjfr| |}nt|t	r)| 
|}n|t|ttjfr7| |}nnt|trGt| jrG| |}n^t|rdt| jsUt| td| || jj tj}nAt|rn| |}n7t|rz| |tj}n+t|st |r| !|S t"|rt| jst| td| || jj tj}nt#S t|tj$rt|jrddl%m&} ||S |S Nrx   ra   r   )rb   )'r	  r   r  r   r   r   r   r+  r  r   r  r   r,  r  r   rC   rx   r  r   r  rA   r#   r   _addsub_int_array_or_scalarr   r   rb  r  r  r@   r  r9   r:   r  r>   NotImplementedndarrayr  rb   ru   r   other_dtyper   rb   rk   rk   rl   r    sD   







	zDatetimeLikeArrayMixin.__add__c                 C  s
   |  |S r|   )r  r  rk   rk   rl   __radd__  s   
zDatetimeLikeArrayMixin.__radd____sub__c                 C  s  t |dd }|tu r|  }nt|tttjfr| | }nt|t	r+| 
| }nt|ttjfr9| |}nut|rVt| jsGt| td| || jj tj}nXt|tra| |}nMt|rl| | }nBt|rx| |tj}n6t|st |r| !|}n(t|r| "|}nt#|rt| jst| td| || jj tj}nt$S t|tj%rt|jrddl&m'} ||S |S r  )(r	  r   r  r   r   r   r   r+  r  r   r  r   r,  r  r   r  rA   rx   r#   r   r  r   r   rb  r  r   r  rC   r  r@   r  r9   r:   r  r  r>   r  r  r  rb   r  rk   rk   rl   r    sH   







zDatetimeLikeArrayMixin.__sub__c                 C  s   t |dd }t|r-t| jr-t|rt||  S t|ts)ddl	m
} ||}||  S t| jrLt|drLt|jsLtdt| j dt|j t| jrct|rctdt| j d|j t| jrrtd| } |  | S | |  S )Nrx   r   r|  r  z from rb   )r	  r8   rC   rx   r   r   r   r   rd   r  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 r|   rA   rx   r   r   ru   r   r   rk   rk   rl   __iadd__*  
   
zDatetimeLikeArrayMixin.__iadd__c                 C  s2   | | }|d d  | d d < t | js|j| _| S r|   r  r  rk   rk   rl   __isub__3  r  zDatetimeLikeArrayMixin.__isub__r   r/  
int | Noner/  c                K  s   t d| t || j t| jr<tj| j	d||d}|t
u r$t
S |	d}|du s2| jdkr7| |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   )nvvalidate_minvalidate_minmax_axisr   rA   rx   rL   nanminrq   r   r   r   _from_backing_data_wrap_reduction_resultru   r   r/  rQ  r   rk   rk   rl   min?     



zDatetimeLikeArrayMixin.minc                K  s   t d| t || j t| jr<tj| j	d||d}|t
u r$|S |	d}|du s2| jdkr7| |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  validate_maxr  r   rA   rx   rL   nanmaxrq   r   r   r   r  r  r  rk   rk   rl   max\  r  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/  rk  )
rA   rx   r   r   rg   rL   nanmeanrq   rK   r  )ru   r/  r   r   rk   rk   rl   meany  s   
zDatetimeLikeArrayMixin.meanc                K  s   t d| |d urt|| jkrtdt| jr>tj| j	
d||d}|
d}|d u s4| jdkr9| |S | |S tj| j	||d}| ||S )Nrk   z abs(axis) must be less than ndimr  r  r   r   )r  validate_medianabsr   r  rA   rx   rL   	nanmedianrq   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   )rk  )	rK   rP   r   rq   rx   r   r   r  r  )ru   r  rk  i8modesnpmodesrk   rk   rl   _mode  s   
zDatetimeLikeArrayMixin._mode)rr   rs   )NNF)rx   ry   rr   rz   )rr   r   )r   r   rr   r   )F)r   r   r   rs   rr   r   )r   r   r   rs   rr   rz   )rr   rp   )rr   r   )rr   r   )r   rs   r|   )rx   r   rr   rp   )r   r+   rr   r   )ru   rc   r   r   rr   rc   )ru   rc   r   r)   rr   r   )rr   r   )r   r   r   r   rr   rz   )Tr   rs   )ru   rc   rr   rc   )rx   r   rr   r`   )rx   r   rr   rb   ).)rx   ry   rr   r$   )r   )r   r   r   r   r   r   rr   rc   )r  )r  rs   r   rs   r  rs   )r  rs   rr   r   )r  rs   )r   rs   rr   r!  )rr   r&  )r   rp   rr   rp   rr   rz   )rr   r=  )rr   rA  rr   r   )r   r   rr   rc   )rr   r`   )r   r  )r   r   rr   r   )r   r   rr   ra   )r   r  )r   ra   rr   r   )r   rp   )ru   rc   rJ  r   rr   rc   )r   r  r/  rs   )r/  rs   r   r  )r  rs   )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   r5  r7  r   r:  r   setterr>  r@  rD  rF  r<  rN  rZ  r\  r^  rm  r^   rn  ro  rp  rq  rr  rs  rt  ru  rv  rw  rx  ry  r   r  r  r  r  r  r  r  r  r  r  r  r  r  r  r\   r  r  r  r  r  r  r  r  r  r  r  __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	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   rr   r   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   r8  r   r   )ru   r   r   rk   rk   rl   strftime  s   1zDatelikeOps.strftimeN)r   r   rr   r   )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)
    TimelikeOpsTre  c                      s  e Zd ZU dZded< dejdfd8dd	Zed
d Z	e
d9ddZe
d:ddZd; fddZdd Zeee jddd<ddZeee jddd<d d!Zeee jd"dd<d#d$Zdd%d&d=d*d+Zdd%d&d=d,d-Zd>d/d0Zd1d2 Z	3	d?d@ fd6d7Z  ZS )Are  zK
    Common ops for TimedeltaIndex/DatetimeIndex, but not PeriodIndex.
    znp.dtype_default_dtypeNFr   rs   c                 C  s  t |dd}t|tr|jdtd}t|dd }|d u }|tjur#|nd }t|t| ri|r/n|d u r7|j	}n|rI|j	rIt
|}t||j	d\}}|d urbt|}t||jsbtd| d|j |j}|j}n|d u rp| j}t|tjstd	t|j d
t| j d|jdvrtd|jdkr|| j}| ||}|dkrtdt| j d|r| }|rt
|}tj| ||d || _|d u r|d urt| | | d S d S d S )NTr  r   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   rx   )rY   r   rV   to_numpyr   r	  r   
no_defaultr   r   r   validate_inferred_freqrE   r<   rx   r   rq   r  r   r  r  rg   r   r   _validate_dtyper   r   r   r   r<  )ru   r   rx   r   r   r@  explicit_none_rk   rk   rl   r     s`   



zTimelikeOps.__init__c                 C  r{   r|   r}   )r   r   rx   rk   rk   rl   r    s   zTimelikeOps._validate_dtyperr   r   c                 C  s   t | jjS r|   )r   rq   rx   rt   rk   rk   rl   r     s   zTimelikeOps._resor   c                 C  s
   t | jS r|   )dtype_to_unitrx   rt   rk   rk   rl   r    r6  zTimelikeOps._unitufuncnp.ufuncmethodc                   s`   |t jt jt jfv r"t|dkr"|d | u r"t||| jfi |S t j||g|R i |S )Nr   r   )	r   isnanisinfisfiniter   r	  rq   r   __array_ufunc__)ru   r  r  inputsrQ  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:   rx   r   tz_localize_roundr   r   r   r  r   nanosr   r   r!   r:  r   rq   r  )
ru   r   rP   r	  r
  naiver   r   r  	result_i8rk   rk   rl   r    s   




zTimelikeOps._roundround)rg  raisec                 C     |  |tj||S r|   )r  r    NEAREST_HALF_EVENru   r   r	  r
  rk   rk   rl   r       zTimelikeOps.roundfloorc                 C  r  r|   )r  r    MINUS_INFTYr  rk   rk   rl   r    r  zTimelikeOps.floorceilc                 C  r  r|   )r  r    
PLUS_INFTYr  rk   rk   rl   r    r  zTimelikeOps.ceilTr  r   r  r/  c                C     t j| j|||  dS Nr  )rL   nananyrq   rK   ru   r   r/  rk   rk   rl   r        zTimelikeOps.anyc                C  r  r  )rL   nanallrq   rK   r  rk   rk   rl   r     r  zTimelikeOps.allrz   c                 C  s
   d | _ d S r|   r;  rt   rk   rk   rl   r   "  s   
zTimelikeOps._maybe_clear_freqc                 C  sJ   |du rnt | dkrt|trn|dksJ t| j}|  }||_|S )z
        Helper to get a view on the same data, with a new freq.

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

        Returns
        -------
        Same type as self
        Nr   r  )r   r   r   r   r@  r   r   )ru   r   arrrk   rk   rl   
_with_freq%  s   
zTimelikeOps._with_freqr   na_sentinelsortc                   sh   | j d ur-tjt| tjd}|  }|r)| j jdk r)|d d d }|d d d }||fS t j|dS )Nr   r   r   )r#  )	r   r   aranger   intpr   r   r   	factorize)ru   r#  r$  codesuniquesr   rk   rl   r'  E  s   
zTimelikeOps.factorizer  )rr   r   r  )r  r  r  r   )r  r  )r   r  r/  rs   rr   rs   r  )r   F)r#  r   r$  rs   )rg   rh   ri   rj   r  r   r  r   r  r  r4   r   r  r  r  r2   
_round_doc_round_exampler   r  _floor_exampler  _ceil_exampler  r   r   r   r"  r'  r  rk   rk   r   rl   re    s2   
 C

"r   rs   cls_namer   c                 C  s   t | dst| dkrt| } t| } d}nt| tr%td| dt| dd} t| t	r=| j
dtd	} d}| |fS t| tjtfsNt| } | |fS t| tr_| jj| jtd
j} d}| |fS )Nrx   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  taker(  r   _values)r~   r   r.  rk   rk   rl   !ensure_arraylike_for_datetimelikeZ  s&   




	
r1  rJ  rz   rr   c                 C  r   r|   rk   rJ  rk   rk   rl   validate_periodsx  rw   r3  floatr   c                 C  r   r|   rk   r2  rk   rk   rl   r3  }  rw   float | Noner  c                 C  s:   | durt | rt| } | S t | std|  | S )a9  
    If a `periods` argument is passed to the Datetime/Timedelta Array/Index
    constructor, cast it to an integer.

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

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

    Raises
    ------
    TypeError
        if periods is None, float, or int
    Nzperiods must be a number, got )r   is_floatr   r  r   r2  rk   rk   rl   r3    s   

tuple[BaseOffset | None, bool]c                 C  sF   |dur| dur| |krt d| d| j | du 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.
    NrK  rL  F)r  r>  )r   r@  
freq_inferrk   rk   rl   r    s   r  c                 C  s6   d}t | ts| dkrt| } | |fS 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   r8  rk   rk   rl   maybe_infer_freq  s   
r9  rx   DatetimeTZDtype | np.dtypec                 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   r  r   datetime_datar   rk   rk   rl   r     s   
r   )r   rs   r.  r   )rJ  rz   rr   rz   )rJ  r4  rr   r   )rJ  r5  rr   r  )rr   r7  )rx   r:  rr   r   )
__future__r   r   r   rb  typingr   r   r   r   r	   r
   r   r   r   r   r   numpyr   pandas._libsr   r   pandas._libs.arraysr   pandas._libs.tslibsr   r   r   r   r   r   r   r   r   r   r   r   r   r   pandas._libs.tslibs.fieldsr    r!   pandas._libs.tslibs.np_datetimer"   pandas._libs.tslibs.timestampsr#   pandas._typingr$   r%   r&   r'   r(   r)   r*   r+   r,   r-   pandas.compat.numpyr.   r  pandas.errorsr/   r0   r1   pandas.util._decoratorsr2   r3   r4   pandas.util._exceptionsr5   pandas.core.dtypes.commonr6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   pandas.core.dtypes.dtypesrF   rG   pandas.core.dtypes.genericrH   rI   pandas.core.dtypes.missingrJ   rK   pandas.corerL   rM   pandas.core.algorithmsrN   rO   rP   rQ   pandas.core.arraylikerR   pandas.core.arrays._mixinsrS   rT   pandas.core.arrays.baserU   pandas.core.arrays.integerrV   pandas.core.commoncorecommonr   pandas.core.constructionrW   r  rX   rY   pandas.core.indexersrZ   r[   pandas.core.ops.commonr\   pandas.core.ops.invalidr]   r^   pandas.tseriesr_   r  r`   ra   rb   r   rc   	Exceptionrf   rd   r  r*  r+  r,  r-  r  re  r1  r3  r  r9  r   rk   rk   rk   rl   <module>   s    0@0H	            ':? 
O

%