
    OwgƓ                       d dl mZ d dlmZ d dlZd dlmZmZ d dlZ	d dl
mZmZ d dlmZmZmZmZmZmZmZmZmZ d dlmZ d dlmZmZ d d	lmZmZmZm Z m!Z! d d
l"m#Z$ d dl%m&Z& d dl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z. d dl/m0Z0 d dl1m2Z2 d dl3m4Z4m5Z5 d dl6m7Z7 d dl8m9Z: d dl;m<Z< d dl=m>c m?Z@ d dlAmBZB erd dlCmDZD d dlEmFZFmGZGmHZHmIZImJZJmKZK d dlLmMZM d dlNZNddZO G d de:j                        ZQ	 	 	 d	 	 	 	 	 d dZRd!d"dZSd#d$dZTd%dZUy)&    )annotations)	timedeltaN)TYPE_CHECKINGcast)libtslibs)	NaTNaTTypeTick	Timedeltaastype_overflowsafeget_supported_dtypeiNaTis_supported_dtypeperiods_per_second)cast_from_unit_vectorized)get_timedelta_daysget_timedelta_field)array_to_timedelta64floordiv_object_arrayints_to_pytimedeltaparse_timedelta_unittruediv_object_array)function)validate_endpoints)TD64NS_DTYPEis_float_dtypeis_integer_dtypeis_object_dtype	is_scalaris_string_dtypepandas_dtype)ExtensionDtype)isna)nanops	roperator)datetimelike_accumulations)datetimelike)generate_regular_range)unpack_zerodim_and_defer)Iterator)AxisIntDateTimeErrorChoicesDtypeObjNpDtypeSelfnpt	DataFramec                J    dfd}| |_         d| d|_        t        |      S )Nc                    | j                   }dk(  rt        || j                        }nt        || j                        }| j                  r| j                  |d d      }|S )Ndaysresofloat64)
fill_valueconvert)asi8r   _cresor   _hasna_maybe_mask_results)selfvaluesresultaliass      T/var/www/horilla/myenv/lib/python3.12/site-packages/pandas/core/arrays/timedeltas.pyfz_field_accessor.<locals>.fR   sa    F?'T[[AF
 )T[[IF;;--4 . F     
)returnz
np.ndarray)__name____doc__property)namerC   	docstringrE   s    `  rD   _field_accessorrN   Q   s+      AJYKr"AIA;rF   c                      e Zd ZU dZdZ ej                  dd      Zeej                  e	fZ
d ZdZedUd       ZdZg Zd	ed
<   g Zd	ed<   dgZd	ed<   g dZd	ed<   eez   ez   dgz   Zd	ed<   g dZd	ed<   dVdZedWd       ZdZeZed        Zedef	 	 	 	 	 	 	 dX fd       ZeddddYd       Zedde jB                  dd	 	 	 dYd       Z"e	 dZdd	 	 	 d[d       Z#d\d Z$d]d!Z%d^d"Z&d_d`d$Z'dad%Z(dddddd#d&d'	 	 	 	 	 	 	 	 	 dbd(Z)dddd)dd#d*	 	 	 	 	 	 	 	 	 dcd+Z*d#d,dd fd-Z+dedfd.Z,ddd/	 	 	 dgd0Z-d1 Z. e/d2      dhd3       Z0e0Z1d4 Z2d5 Z3did6Z4 e/d7      d8        Z5 e/d9      d:        Z6 e/d;      d<        Z7 e/d=      d>        Z8 e/d?      d@        Z9 e/dA      dB        Z: e/dC      dD        Z; e/dE      dF        Z<djdGZ=djdHZ>djdIZ?dkdJZ@dldKZA eBj                  dL      ZD eEdMdMeD      ZF eBj                  dN      ZG eEdOdOeG      ZH eBj                  dP      ZI eEdQdQeI      ZJ eBj                  dR      ZK eEdSdSeK      ZLedmdT       ZM xZNS )nTimedeltaArrayal  
    Pandas ExtensionArray for timedelta data.

    .. warning::

       TimedeltaArray is currently experimental, and its API may change
       without warning. In particular, :attr:`TimedeltaArray.dtype` is
       expected to change to be an instance of an ``ExtensionDtype``
       subclass.

    Parameters
    ----------
    values : array-like
        The timedelta data.

    dtype : numpy.dtype
        Currently, only ``numpy.dtype("timedelta64[ns]")`` is accepted.
    freq : Offset, optional
    copy : bool, default False
        Whether to copy the underlying array of data.

    Attributes
    ----------
    None

    Methods
    -------
    None

    Examples
    --------
    >>> pd.arrays.TimedeltaArray._from_sequence(pd.TimedeltaIndex(['1h', '2h']))
    <TimedeltaArray>
    ['0 days 01:00:00', '0 days 02:00:00']
    Length: 2, dtype: timedelta64[ns]
    timedeltaarrayr	   nsc                .    t        j                  | d      S Nm)r   is_np_dtypexs    rD   <lambda>zTimedeltaArray.<lambda>   s    S__Q%< rF   )r   timedelta64c                    t         S Nr   r@   s    rD   _scalar_typezTimedeltaArray._scalar_type   s    rF   i  z	list[str]
_other_ops	_bool_opsfreq_object_ops)r6   secondsmicrosecondsnanoseconds
_field_opsunit_datetimelike_ops)to_pytimedeltatotal_secondsroundfloorceilas_unit_datetimelike_methodsc                    |j                  d      }|t        j                  k(  rt        S t        j                  || j
                        S )Ni8r7   )viewr	   _valuer   _from_value_and_resor=   )r@   rX   ys      rD   	_box_funczTimedeltaArray._box_func   s6    FF4L

?J--adkkBBrF   c                .    | j                   j                  S )a3  
        The dtype for the TimedeltaArray.

        .. warning::

           A future version of pandas will change dtype to be an instance
           of a :class:`pandas.api.extensions.ExtensionDtype` subclass,
           not a ``numpy.dtype``.

        Returns
        -------
        numpy.dtype
        )_ndarraydtyper^   s    rD   rz   zTimedeltaArray.dtype   s    " }}"""rF   Nc                z    t        |      }t        |j                         ||j                  k7  rt        d      |S )Nz'Values resolution does not match dtype.)_validate_td64_dtyperz   
ValueError)clsrA   rz   s      rD   _validate_dtypezTimedeltaArray._validate_dtype   s7     %U+V\\*FLL FGGrF   c                4   t        j                  |d      sJ t        j                  |      rJ t	        |t
        j                        sJ t        |             ||j                  k(  sJ |t	        |t              sJ t        | -  ||      }||_        |S )NrU   )rA   rz   )r   rV   r   is_unitless
isinstancenpndarraytyperz   r   super_simple_new_freq)r~   rA   rb   rz   rB   	__class__s        rD   r   zTimedeltaArray._simple_new   s     uc***%%e,,,&"**-;tF|;-$$$|z$555$F%$@rF   Frz   copyc                   |rt        |      }t        ||d       \  }}|t        ||d      }| j                  ||j                  |      S )Nr   rh   Fr   rz   rb   )r|   sequence_to_td64nsr   r   rz   )r~   datarz   r   rb   s        rD   _from_sequencezTimedeltaArray._from_sequence   sN    (/E'4dC
d&t5uEDt4::DAArF   )rz   r   rb   rh   c                   |rt        |      }|dvsJ t        |||      \  }}|t        ||d      }| j                  ||j                  |      }|j                  |i        |S )zo
        _from_sequence_not_strict but without responsibility for finding the
        result's `freq`.
        Yrv   Mr   Fr   r   )r|   r   r   r   rz   _maybe_pin_freq)r~   r   rz   r   rb   rh   inferred_freqrB   s           rD   _from_sequence_not_strictz(TimedeltaArray._from_sequence_not_strict   ss     (/E?***0DtLm&t5uEDTZZmLtR(rF   rh   c                  t        j                  |      }| t        d |||fD              rt        d      t	        j
                  ||||      dk7  rt        d      |t        |      j                  d      }|t        |      j                  d      }||dvrt        d      d}|||j                  |d	      }|||j                  |d	      }t        |      \  }}|t        |||||
      }	n:t        j                  |j                  |j                  |      j                  d      }	|s|	dd  }	|s|	d d }	|	j                  d| d      }
| j                  |
|
j                   |      S )Nc              3  $   K   | ]  }|d u  
 y wr\    ).0rX   s     rD   	<genexpr>z1TimedeltaArray._generate_range.<locals>.<genexpr>  s     IaT	Is   z1Must provide freq argument if no data is supplied   zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedrR   )smsusrR   z+'unit' must be one of 's', 'ms', 'us', 'ns'F)round_okr   rr      zm8[]r   )dtlvalidate_periodsanyr}   comcount_not_noner   ro   r   r)   r   linspacert   astypers   r   rz   )r~   startendperiodsrb   closedrh   left_closedright_closedindex
td64valuess              rD   _generate_rangezTimedeltaArray._generate_range  s    &&w/<CIGUC3HIIPQQeS'48A=< 
 e$,,T2E?C.((.C22 !NOOD!1MM$M7E?t/++dU+3C$6v$>!\*5#w4PEKKcjj'BII$OE!"IE#2JEZZ#dV1.
z1A1AMMrF   c                $   t        || j                        s|t        urt        d      | j	                  |       |t        u r*t        j                  |j                  | j                        S |j                  | j                        j                  S )Nz'value' should be a Timedelta.)r   r_   r	   r}   _check_compatible_withr   rZ   rt   rh   ro   asm8r@   values     rD   _unbox_scalarzTimedeltaArray._unbox_scalar?  sl    %!2!23S8H=>>##E*C<>>%,,		::==+000rF   c                    t        |      S r\   r]   r   s     rD   _scalar_from_stringz"TimedeltaArray._scalar_from_stringH  s    rF   c                     y r\   r   r@   others     rD   r   z%TimedeltaArray._check_compatible_withK  s    rF   Tc                   t        |      }t        j                  |d      r|| j                  k(  r|r| j	                         S | S t        |      rIt        | j                  |d      }t        |       j                  ||j                  | j                        S t        d| j                   d| d      t        j                  j                  | ||      S )NrU   Fr   r   zCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r"   r   rV   rz   r   r   r   ry   r   r   rb   r}   r   DatetimeLikeArrayMixinr   )r@   rz   r   
res_valuess       rD   r   zTimedeltaArray.astypeR  s    
 U#??5#&

"99;&!%(0ER
Dz--j&6&6TYY .   !*4::,d5' BF F 
 ))00u40HHrF   c              #  4  K   | j                   dkD  r!t        t        |             D ]	  }| |     y | j                  }t        |       }d}||z  dz   }t        |      D ]3  }||z  }t	        |dz   |z  |      }t        ||| d      }|E d {    5 y 7 w)Nr   i'  Tbox)ndimrangelenry   minr   )	r@   ir   length	chunksizechunksstart_iend_i	converteds	            rD   __iter__zTimedeltaArray.__iter__m  s     99q=3t9% 1g ==DYFI	)Q.F6] %i-QUi/8/WU0CN	$$$	% %s   BBBBr   )axisrz   outkeepdimsinitialskipna	min_countc                   t        j                  d||||d       t        j                  | j                  |||      }| j                  ||      S )Nr   )rz   r   r   r   )r   r   r   )nvvalidate_sumr%   nansumry   _wrap_reduction_result)	r@   r   rz   r   r   r   r   r   rB   s	            rD   sumzTimedeltaArray.sum  sP     	%gV	
 MMVy
 **488rF   r   )r   rz   r   ddofr   r   c                   t        j                  d|||dd       t        j                  | j                  |||      }|| j
                  dk(  r| j                  |      S | j                  |      S )Nr   )rz   r   r   std)fname)r   r   r   r   )r   validate_stat_ddof_funcr%   nanstdry   r   rw   _from_backing_data)r@   r   rz   r   r   r   r   rB   s           rD   r   zTimedeltaArray.std  si     	""%B%	
 t}}4TR<499>>>&))&&v..rF   )r   c                  |dk(  rZt        t        |      } || j                  j                         fd|i|}t	        |       j                  |d | j                        S |dk(  rt        d      t        | $  |fd|i|S )Ncumsumr   )rb   rz   cumprodz$cumprod not supported for Timedelta.)
getattrr'   ry   r   r   r   rz   	TypeErrorr   _accumulate)r@   rL   r   kwargsoprB   r   s         rD   r   zTimedeltaArray._accumulate  s    83T:B**,FVFvFF:))&t4::)NNYBCC 7&tEFEfEErF   c                "    ddl m}  || d      S )Nr   get_format_timedelta64Tr   )pandas.io.formats.formatr   )r@   boxedr   s      rD   
_formatterzTimedeltaArray._formatter  s    C%d55rF   )na_repdate_formatc               n    ddl m}  || |      } t        j                  |dd      | j                        S )Nr   r   r   )r   r   r   
frompyfuncry   )r@   r   r   r   r   	formatters         rD   _format_native_typesz#TimedeltaArray._format_native_types  s6     	D +48	 .r}}Y1-dmm<<rF   c                    t        |t              rJ t        dt        |      j                   dt        |       j                         )Nzcannot add the type z to a )r   r   r   r   rI   r   s     rD   _add_offsetzTimedeltaArray._add_offset  sE    eT***"4;#7#7"8tDz?R?R>ST
 	
rF   __mul__c                $   t        |      r| j                  |z  }|j                  j                  dk7  r!t	        dt        |      j                         d }| j                  +t        |      s | j                  |z  }|j                  dk(  rd }t        |       j                  ||j                  |      S t        |d      st        j                  |      }t        |      t        |       k7  r+t        j                   |j                  d      st#        d      t%        |j                        rq| j                  }t'        t        |             D cg c]  }||   ||   z   }}t        j                  |      }t        |       j                  ||j                        S | j                  |z  }|j                  j                  dk7  r!t	        dt        |      j                         t        |       j                  ||j                        S c c}w )NrU   zCannot multiply with r   r   rz   z$Cannot multiply with unequal lengthsrz   )r    ry   rz   kindr   r   rI   rb   r$   nr   hasattrr   arrayr   r   rV   r}   r   r   )r@   r   rB   rb   arrr  s         rD   r   zTimedeltaArray.__mul__  s   U]]U*F||  C'  "7U8L8L7M NOODyy$T%[yy5(66Q;D:))&4)PPug&HHUOEu:T"3??5;;+L CDD5;;' --C16s4y1ABAc!fuQx'BFBXXf%F:))&)EE &<<# 3DK4H4H3IJKKDz%%fFLL%AA Cs   Hc                   t        || j                        rt        |      }t        d|      t        u rPt        j                  | j                  t
        j                        }|j                  t
        j                         |S  || j                  |      S |t        j                  t        j                  fv r7t        dt!        |      j"                   dt!        |       j"                          || j                  |      }d}| j$                  9| j$                  |z  }|j&                  dk(  r| j$                  j&                  dk7  rd}t!        |       j)                  ||j*                  |      S )zv
        Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__
        with scalar 'other'.
        Timedelta | NaTTyper   zCannot divide z by Nr   r   )r   _recognized_scalarsr   r   r	   r   emptyshaper9   fillnanry   r&   rtruediv	rfloordivr   r   rI   rb   nanosr   rz   )r@   r   r   resrB   rb   s         rD   _scalar_divlike_opz!TimedeltaArray._scalar_divlike_op  s0   
 eT556e$E )51S8hhtzz< 
 dmmU++ i(()*=*=>>$T%[%9%9$:$tDz?R?R>ST  u-FDyy$ yy5(::?tyy!';  D:))&4)PPrF   c                    t        |d      st        j                  |      }t        |      t        |       k7  rt	        d      |S )Nrz   z*Cannot divide vectors with unequal lengths)r  r   r  r   r}   r   s     rD   _cast_divlike_opzTimedeltaArray._cast_divlike_op'  s:    ug&HHUOEu:T"IJJrF   c                Z    || j                   t        j                  |            }t        |j                        st        |j                        rH|t        j                  t        j                  fv r&t        |       j                  ||j                        S |t        j                  t        j                  fv rp| j                         t        |      z  }|j                         rD|j                  t        j                         }t        j"                  ||t        j$                         |S )z
        Shared logic for __truediv__, __floordiv__, and their reversed versions
        with timedelta64-dtype ndarray other.
        r   )ry   r   asarrayr   rz   r   operatortruedivfloordivr   r   r&   r  r$   r   r   r9   putmaskr  )r@   r   r   rB   masks        rD   _vector_divlike_opz!TimedeltaArray._vector_divlike_op0  s     DMM2::e#45U[[)^EKK-HbU
 O
 :))&)EE(##Y%8%89999;e,Dxxzrzz2

640rF   __truediv__c                   t         j                  }t        |      r| j                  ||      S | j	                  |      }t        j                  |j                  d      s*t        |j                        st        |j                        r| j                  ||      S t        |j                        rt        j                  |      }| j                  dkD  rYt        | |      D cg c]
  \  }}||z   }}}|D cg c]  }|j!                  dd       }}t        j"                  |d      }|S t%        | j&                  |      }|S t(        S c c}}w c c}w NrU   r   r   r   )r   )r  r  r    r  r  r   rV   rz   r   r   r  r   r   r  r   zipreshapeconcatenater   ry   NotImplemented	r@   r   r   leftrightres_colsrX   	res_cols2rB   s	            rD   r  zTimedeltaArray.__truediv__F  s    U**5"55%%e,OOEKK-,ekk***5"555;;'JJu%Eyy1}<?e<LM[T5D5LMM7?@!QYYq"-@	@	: M .dmmUCM "! N@s   #E9E__rtruediv__c                   t         j                  }t        |      r| j                  ||      S | j	                  |      }t        j                  |j                  d      r| j                  ||      S t        |j                        r?t        t        |             D cg c]  }||   | |   z   }}t        j                  |      S t        S c c}w rT   )r&   r  r    r  r  r   rV   rz   r  r   r   r   r   r  r"  )r@   r   r   r  result_lists        rD   r(  zTimedeltaArray.__rtruediv__c  s     U**5"55%%e,??5;;,**5"55U[[) 8=SY7GH!58d1g-HKH88K(( "!	 Is   C__floordiv__c                   t         j                  }t        |      r| j                  ||      S | j	                  |      }t        j                  |j                  d      s*t        |j                        st        |j                        r| j                  ||      S t        |j                        rt        j                  |      }| j                  dkD  rXt        | |      D cg c]
  \  }}||z   }}}|D cg c]  }|j!                  dd       }}t        j"                  |d      }nt%        | j&                  |      }|j                  t(        k(  sJ |S t*        S c c}}w c c}w r  )r  r  r    r  r  r   rV   rz   r   r   r  r   r   r  r   r  r   r!  r   ry   objectr"  r#  s	            rD   r+  zTimedeltaArray.__floordiv__x  s"   U**5"55%%e,OOEKK-,ekk***5"55U[[)JJu%Eyy1}=@u=MNkdEDEMNN7?@!QYYq"-@	@	:.t}}eD<<6)))M "! O@s   #E9E%__rfloordiv__c                   t         j                  }t        |      r| j                  ||      S | j	                  |      }t        j                  |j                  d      r| j                  ||      S t        |j                        rAt        t        |             D cg c]  }||   | |   z   }}t        j                  |      }|S t        S c c}w rT   )r&   r  r    r  r  r   rV   rz   r  r   r   r   r   r  r"  )r@   r   r   r  r*  rB   s         rD   r.  zTimedeltaArray.__rfloordiv__  s      U**5"55%%e,??5;;,**5"55U[[)8=c$i8HI158tAw.IKIXXk*FM "! Js   C__mod__c                Z    t        || j                        rt        |      }| | |z  |z  z
  S r\   r   r  r   r   s     rD   r0  zTimedeltaArray.__mod__  s2     eT556e$Etu}---rF   __rmod__c                Z    t        || j                        rt        |      }||| z  | z  z
  S r\   r2  r   s     rD   r3  zTimedeltaArray.__rmod__  s2     eT556e$E---rF   
__divmod__c                f    t        || j                        rt        |      }| |z  }| ||z  z
  }||fS r\   r2  r@   r   res1res2s       rD   r5  zTimedeltaArray.__divmod__  s?     eT556e$Eu}dUl"TzrF   __rdivmod__c                f    t        || j                        rt        |      }|| z  }||| z  z
  }||fS r\   r2  r7  s       rD   r:  zTimedeltaArray.__rdivmod__  s?     eT556e$E}td{"TzrF   c                    d }| j                   | j                    }t        |       j                  | j                   | j                  |      S Nr   )rb   r   r   ry   rz   )r@   rb   s     rD   __neg__zTimedeltaArray.__neg__  sB    99 II:DDz%%t}}nDJJT%RRrF   c                    t        |       j                  | j                  j                         | j                  | j
                        S r=  )r   r   ry   r   rz   rb   r^   s    rD   __pos__zTimedeltaArray.__pos__  s:    Dz%%MM 

 & 
 	
rF   c                    t        |       j                  t        j                  | j                        | j
                        S )Nr   )r   r   r   absry   rz   r^   s    rD   __abs__zTimedeltaArray.__abs__  s-    Dz%%bffT]]&;4::%NNrF   c                l    t        | j                        }| j                  | j                  |z  d      S )a{  
        Return total duration of each element expressed in seconds.

        This method is available directly on TimedeltaArray, TimedeltaIndex
        and on Series containing timedelta values under the ``.dt`` namespace.

        Returns
        -------
        ndarray, Index or Series
            When the calling object is a TimedeltaArray, the return type
            is ndarray.  When the calling object is a TimedeltaIndex,
            the return type is an Index with a float64 dtype. When the calling object
            is a Series, the return type is Series of type `float64` whose
            index is the same as the original.

        See Also
        --------
        datetime.timedelta.total_seconds : Standard library version
            of this method.
        TimedeltaIndex.components : Return a DataFrame with components of
            each Timedelta.

        Examples
        --------
        **Series**

        >>> s = pd.Series(pd.to_timedelta(np.arange(5), unit='d'))
        >>> s
        0   0 days
        1   1 days
        2   2 days
        3   3 days
        4   4 days
        dtype: timedelta64[ns]

        >>> s.dt.total_seconds()
        0         0.0
        1     86400.0
        2    172800.0
        3    259200.0
        4    345600.0
        dtype: float64

        **TimedeltaIndex**

        >>> idx = pd.to_timedelta(np.arange(5), unit='d')
        >>> idx
        TimedeltaIndex(['0 days', '1 days', '2 days', '3 days', '4 days'],
                       dtype='timedelta64[ns]', freq=None)

        >>> idx.total_seconds()
        Index([0.0, 86400.0, 172800.0, 259200.0, 345600.0], dtype='float64')
        N)r:   )r   r=   r?   r<   )r@   ppss     rD   rk   zTimedeltaArray.total_seconds  s1    l !-''		CD'IIrF   c                ,    t        | j                        S )a  
        Return an ndarray of datetime.timedelta objects.

        Returns
        -------
        numpy.ndarray

        Examples
        --------
        >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='D')
        >>> tdelta_idx
        TimedeltaIndex(['1 days', '2 days', '3 days'],
                        dtype='timedelta64[ns]', freq=None)
        >>> tdelta_idx.to_pytimedelta()
        array([datetime.timedelta(days=1), datetime.timedelta(days=2),
               datetime.timedelta(days=3)], dtype=object)
        )r   ry   r^   s    rD   rj   zTimedeltaArray.to_pytimedelta  s    $ #4==11rF   aC  Number of days for each element.

    Examples
    --------
    For Series:

    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='d'))
    >>> ser
    0   1 days
    1   2 days
    2   3 days
    dtype: timedelta64[ns]
    >>> ser.dt.days
    0    1
    1    2
    2    3
    dtype: int64

    For TimedeltaIndex:

    >>> tdelta_idx = pd.to_timedelta(["0 days", "10 days", "20 days"])
    >>> tdelta_idx
    TimedeltaIndex(['0 days', '10 days', '20 days'],
                    dtype='timedelta64[ns]', freq=None)
    >>> tdelta_idx.days
    Index([0, 10, 20], dtype='int64')r6   a  Number of seconds (>= 0 and less than 1 day) for each element.

    Examples
    --------
    For Series:

    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='s'))
    >>> ser
    0   0 days 00:00:01
    1   0 days 00:00:02
    2   0 days 00:00:03
    dtype: timedelta64[ns]
    >>> ser.dt.seconds
    0    1
    1    2
    2    3
    dtype: int32

    For TimedeltaIndex:

    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='s')
    >>> tdelta_idx
    TimedeltaIndex(['0 days 00:00:01', '0 days 00:00:02', '0 days 00:00:03'],
                   dtype='timedelta64[ns]', freq=None)
    >>> tdelta_idx.seconds
    Index([1, 2, 3], dtype='int32')rd   a  Number of microseconds (>= 0 and less than 1 second) for each element.

    Examples
    --------
    For Series:

    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='us'))
    >>> ser
    0   0 days 00:00:00.000001
    1   0 days 00:00:00.000002
    2   0 days 00:00:00.000003
    dtype: timedelta64[ns]
    >>> ser.dt.microseconds
    0    1
    1    2
    2    3
    dtype: int32

    For TimedeltaIndex:

    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='us')
    >>> tdelta_idx
    TimedeltaIndex(['0 days 00:00:00.000001', '0 days 00:00:00.000002',
                    '0 days 00:00:00.000003'],
                   dtype='timedelta64[ns]', freq=None)
    >>> tdelta_idx.microseconds
    Index([1, 2, 3], dtype='int32')re   a  Number of nanoseconds (>= 0 and less than 1 microsecond) for each element.

    Examples
    --------
    For Series:

    >>> ser = pd.Series(pd.to_timedelta([1, 2, 3], unit='ns'))
    >>> ser
    0   0 days 00:00:00.000000001
    1   0 days 00:00:00.000000002
    2   0 days 00:00:00.000000003
    dtype: timedelta64[ns]
    >>> ser.dt.nanoseconds
    0    1
    1    2
    2    3
    dtype: int32

    For TimedeltaIndex:

    >>> tdelta_idx = pd.to_timedelta([1, 2, 3], unit='ns')
    >>> tdelta_idx
    TimedeltaIndex(['0 days 00:00:00.000000001', '0 days 00:00:00.000000002',
                    '0 days 00:00:00.000000003'],
                   dtype='timedelta64[ns]', freq=None)
    >>> tdelta_idx.nanoseconds
    Index([1, 2, 3], dtype='int32')rf   c                    ddl m} g d| j                  }|rfd}nd } || D cg c]
  } ||       c}      }|s|j                  d      }|S c c}w )a  
        Return a DataFrame of the individual resolution components of the Timedeltas.

        The components (days, hours, minutes seconds, milliseconds, microseconds,
        nanoseconds) are returned as columns in a DataFrame.

        Returns
        -------
        DataFrame

        Examples
        --------
        >>> tdelta_idx = pd.to_timedelta(['1 day 3 min 2 us 42 ns'])
        >>> tdelta_idx
        TimedeltaIndex(['1 days 00:03:00.000002042'],
                       dtype='timedelta64[ns]', freq=None)
        >>> tdelta_idx.components
           days  hours  minutes  seconds  milliseconds  microseconds  nanoseconds
        0     1      0        3        0             0             2           42
        r   r2   )r6   hoursminutesrd   millisecondsre   rf   c                l    t        |       rt        j                  gt              z  S | j                  S r\   )r$   r   r  r   
components)rX   columnss    rD   rE   z$TimedeltaArray.components.<locals>.f  s)    7FF8c'l22||#rF   c                    | j                   S r\   )rL  rW   s    rD   rE   z$TimedeltaArray.components.<locals>.f  s    ||#rF   )rM  int64)pandasr3   r>   r   )r@   r3   hasnansrE   rX   rB   rM  s         @rD   rL  zTimedeltaArray.components  s_    , 	%
 ++$$ $/QAaD/A]]7+F 0s   A)rH   ztype[Timedelta])rX   np.timedelta64rH   r  )rH   np.dtype[np.timedelta64])rA   znpt.NDArray[np.timedelta64]rb   zTick | Nonerz   rS  rH   r0   )r   boolrH   r0   r\   )rh   z
str | NonerH   r0   )rH   rR  )rH   r  )rH   None)T)r   rT  )rH   r+   )
r   AxisInt | Nonerz   NpDtype | Noner   rT  r   rT  r   int)
r   rV  rz   rW  r   rX  r   rT  r   rT  )rL   strr   rT  )F)r   rT  )r   zstr | floatrH   npt.NDArray[np.object_])rH   r0   )rH   znp.ndarray | Self)rH   rP   )rH   znpt.NDArray[np.float64])rH   rZ  )rH   r3   )OrI   
__module____qualname__rJ   _typr   rZ   _internal_fill_valuer   r   r  _is_recognized_dtype_infer_matchesrK   r_   __array_priority__r`   __annotations__ra   rc   rg   ri   rp   rw   rz   r   r   _default_dtypeclassmethodr   r   r   r   
no_defaultr   r   r   r   r   r   r   r   r   r   r   r   r   r*   r   __rmul__r  r  r  r  r(  r+  r.  r0  r3  r5  r:  r>  r@  rC  rk   rj   textwrapdedentdays_docstringrN   r6   seconds_docstringrd   microseconds_docstringre   nanoseconds_docstringrf   rL  __classcell__)r   s   @rD   rP   rP   g   so   #J D)2>>%6$bnnd;<1N  J	Iy$XK%NJ	N#-#;i#G6(#RyR(9 C # #& E!N   !*6	+  (	
 
 " +/e 	B 	B 
 ^^
  
 8 /3+NKO+N>H+N	+N +N`1 I6%,  $ $9 9 	9 9 9 9.  $ $/ / 	/ / / /, 8< 
F6 (-$	=$	=	 	=
 i('B )'BR H'QR, m," -"8 n-" ."( n-" ."8 o." /"" i(. ). j). *. l+ , m, -S

O7Jr2( %X__	)N8 66>:D'	'8 G -X__	': #L ,HOO	': "K 0 0rF   rP   c                "   |dvsJ d}|t        |      }t        j                  | |d      \  } }t        | t              r| j
                  }| j                  t        k(  st        | j                        rt        | ||      } d}n+t        | j                        rt        | |      \  } }|xr | }nt        | j                        rut        | j                  t              r| j                  }| j                  } nt!        j"                  |       }t%        | |xs d      } t&        | |<   | j)                  d	      } d}ntt+        j,                  | j                  d
      r;t/        | j                        s?t1        | j                        }t3        | |d      } d}nt5        d| j                   d      |st!        j6                  |       } nt!        j8                  | |      } | j                  j:                  d
k(  sJ | j                  dk7  sJ | |fS )a  
    Parameters
    ----------
    data : list-like
    copy : bool, default False
    unit : str, optional
        The timedelta unit to treat integers as multiples of. For numeric
        data this defaults to ``'ns'``.
        Must be un-specified if the data contains a str and ``errors=="raise"``.
    errors : {"raise", "coerce", "ignore"}, default "raise"
        How to handle elements that cannot be converted to timedelta64[ns].
        See ``pandas.to_timedelta`` for details.

    Returns
    -------
    converted : numpy.ndarray
        The sequence converted to a numpy array with dtype ``timedelta64[ns]``.
    inferred_freq : Tick or None
        The inferred frequency of the sequence.

    Raises
    ------
    ValueError : Data cannot be converted to timedelta64[ns].

    Notes
    -----
    Unlike `pandas.to_timedelta`, if setting ``errors=ignore`` will not cause
    errors to be ignored; they are caught and subsequently ignored at a
    higher level.
    r   NrP   )cls_namerh   errorsFr   rR   zm8[ns]rU   r   zdtype z' cannot be converted to timedelta64[ns]r   m8)r   r   !ensure_arraylike_for_datetimeliker   rP   rb   rz   r-  r!   _objects_to_td64nsr   _ints_to_td64nsr   r#   _mask_datar   isnanr   r   rs   r   rV   r   r   r   r   r  r  r  )r   r   rh   rq  r   	copy_mader  	new_dtypes           rD   r   r     s   H &&&M#D)66d-JD$ $'		 zzVtzz:!$T&A	$**	%)$T:i%I	

	# djj.1::D::D88D>D(t|t<T
yy"	S	)!$**-+DJJ7I&t95IDD &,STUUzz$xx4(::??c!!!::rF   c                   d}||nd}| j                   t        j                  k7  r!| j                  t        j                        } d}|dk7  r.d| d}| j	                  |      } t        | t              } d}| |fS | j	                  d      } | |fS )a  
    Convert an ndarray with integer-dtype to timedelta64[ns] dtype, treating
    the integers as multiples of the given timedelta unit.

    Parameters
    ----------
    data : numpy.ndarray with integer-dtype
    unit : str, default "ns"
        The timedelta unit to treat integers as multiples of.

    Returns
    -------
    numpy.ndarray : timedelta64[ns] array converted from data
    bool : whether a copy was made
    FrR   Tztimedelta64[r   r   timedelta64[ns])rz   r   rO  r   rs   r   r   )r   rh   ry  	dtype_strs       rD   ru  ru  F  s      I#4DzzRXX {{288$	t|"4&*	yy#"4|< 	
 ? yy*+?rF   c                    t        j                  | t         j                        }t        |||      }|j	                  d      S )aR  
    Convert a object-dtyped or string-dtyped array into an
    timedelta64[ns]-dtyped array.

    Parameters
    ----------
    data : ndarray or Index
    unit : str, default "ns"
        The timedelta unit to treat integers as multiples of.
        Must not be specified if the data contains a str.
    errors : {"raise", "coerce", "ignore"}, default "raise"
        How to handle elements that cannot be converted to timedelta64[ns].
        See ``pandas.to_timedelta`` for details.

    Returns
    -------
    numpy.ndarray : timedelta64[ns] array converted from data

    Raises
    ------
    ValueError : Data cannot be converted to timedelta64[ns].

    Notes
    -----
    Unlike `pandas.to_timedelta`, if setting `errors=ignore` will not cause
    errors to be ignored; they are caught and subsequently ignored at a
    higher level.
    r   rp  r|  )r   r  object_r   rs   )r   rh   rq  rA   rB   s        rD   rt  rt  n  s6    < ZZBJJ/F!&tFCF;;())rF   c                    t        |       } | t        j                  d      k(  rd}t        |      t	        j
                  | d      st        d|  d      t        |       st        d      | S )Nrr  zhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rU   zdtype 'z,' is invalid, should be np.timedelta64 dtypez;Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns')r"   r   rz   r}   r   rV   r   )rz   msgs     rD   r|   r|     sn    E8 	 o??5#&75')UVWW&VWWLrF   )rL   rY  rC   rY  rM   rY  )FNraise)r   rT  rq  r-   rH   ztuple[np.ndarray, Tick | None])rR   )rh   rY  )Nr  )rq  r-   )rH   r.   )V
__future__r   datetimer   r  typingr   r   numpyr   pandas._libsr   r   pandas._libs.tslibsr	   r
   r   r   r   r   r   r   r   pandas._libs.tslibs.conversionr   pandas._libs.tslibs.fieldsr   r   pandas._libs.tslibs.timedeltasr   r   r   r   r   pandas.compat.numpyr   r   pandas.util._validatorsr   pandas.core.dtypes.commonr   r   r   r   r    r!   r"   pandas.core.dtypes.dtypesr#   pandas.core.dtypes.missingr$   pandas.corer%   r&   pandas.core.array_algosr'   pandas.core.arraysr(   r   pandas.core.arrays._rangesr)   pandas.core.commoncorecommonr   pandas.core.ops.commonr*   collections.abcr+   pandas._typingr,   r-   r.   r/   r0   r1   rP  r3   rg  rN   TimelikeOpsrP   r   ru  rt  r|   r   rF   rD   <module>r     s    "  
 
 
 
 E  / 6   5 + ? 2 =     ;(  ! ,xS__ xB 	#*	]
] !	]
 $]@%P!*HrF   