a
    DBìjÆ“  ã                   @  s  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>  m?Z@ d dlAmBZB e�r�d dlCmDZD d dlEmFZFmGZGmHZHmIZImJZJmKZK d dlLmMZM d dlNZNddddœdd„ZOG dd„ de:jPƒZQd0dd d!d"œd#d$„ZRd1dd&œd'd(„ZSd2d d)œd*d+„ZTd,d-œd.d/„ZUdS )3é    )Ú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©Ú	DataFrameÚstr)ÚnameÚaliasÚ	docstringc                   s.   ddœ‡ fdd„}| |_ d|› d�|_t|ƒS )Nz
np.ndarray©Úreturnc                   sH   | j }ˆ dkrt|| jd�}nt|ˆ | jd�}| jrD| j|d dd�}|S )NÚdays©ZresoÚfloat64)Ú
fill_valueÚconvert)Úasi8r   Ú_cresor   Ú_hasnaÚ_maybe_mask_results)ÚselfÚvaluesÚresult©r5   © ú\/mnt/bigstor/www/usecases/.venv/lib/python3.9/site-packages/pandas/core/arrays/timedeltas.pyÚfR   s    ÿz_field_accessor.<locals>.fÚ
)Ú__name__Ú__doc__Úproperty)r4   r5   r6   rH   rF   rE   rG   Ú_field_accessorQ   s    rM   c                      s®  e Zd ZU dZdZe dd¡Zeeje	fZ
dd„ ZdZedd	œd
d„ƒ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 e dg Zded< g d¢Zded< dddœdd„Zedd	œdd„ƒZd ZeZed!d"„ ƒZed efd#d$dd%d&œ‡ fd'd(„ƒZed d)d*œd+d%d,œd-d.„ƒZed d)e j!d d/œd+d%d,œd0d1„ƒZ"edšd d2œd3d%d4œd5d6„ƒZ#dd	œd7d8„Z$dd	œd9d:„Z%d;d	œd<d=„Z&d›d+d?œd@dA„Z'dBd	œdCdD„Z(d d d d)d d>dEdFœdGdHd+d+dIdJœdKdL„Z)d d d dMd)d>dNœdGdHdId+d+dOœdPdQ„Z*d>dRœdSd+dTœ‡ fdUdV„Z+dœd+dWœdXdY„Z,dd dZœd[d\d]œd^d_„Z-d`da„ Z.e/dbƒd%d	œdcdd„ƒZ0e0Z1dedf„ Z2dgdh„ Z3did	œdjdk„Z4e/dlƒdmdn„ ƒZ5e/doƒdpdq„ ƒZ6e/drƒdsdt„ ƒZ7e/duƒdvdw„ ƒZ8e/dxƒdydz„ ƒZ9e/d{ƒd|d}„ ƒZ:e/d~ƒdd€„ ƒZ;e/d�ƒd‚dƒ„ ƒZ<d d	œd„d…„Z=d d	œd†d‡„Z>d d	œdˆd‰„Z?dŠd	œd‹dŒ„Z@d\d	œd�dŽ„ZAeB Cd�¡ZDeEd�d�eDƒZFeB Cd‘¡ZGeEd’d’eGƒZHeB Cd“¡ZIeEd”d”eIƒZJeB Cd•¡ZKeEd–d–eKƒZLed—d	œd˜d™„ƒZM‡  ZNS )�Ú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]
    Ztimedeltaarrayr   Únsc                 C  s   t  | d¡S )NÚm)r   Úis_np_dtype©ÚxrF   rF   rG   Ú<lambda>�   ó    zTimedeltaArray.<lambda>)r   Útimedelta64ztype[Timedelta]r7   c                 C  s   t S ©N©r   ©rB   rF   rF   rG   Ú_scalar_type“   s    zTimedeltaArray._scalar_typeiè  z	list[str]Ú
_other_opsÚ	_bool_opsÚfreqÚ_object_ops)r9   ÚsecondsÚmicrosecondsÚnanosecondsÚ
_field_opsÚunitÚ_datetimelike_ops)Úto_pytimedeltaÚtotal_secondsÚroundÚfloorÚceilÚas_unitÚ_datetimelike_methodsznp.timedelta64úTimedelta | NaTType)rS   r8   c                 C  s(   |  d¡}|tjkrtS tj|| jd�S )NÚi8r:   )Úviewr   Ú_valuer   Z_from_value_and_resor?   )rB   rS   ÚyrF   rF   rG   Ú	_box_funcª   s    

zTimedeltaArray._box_funcznp.dtype[np.timedelta64]c                 C  s   | 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ÚdtyperY   rF   rF   rG   rs   °   s    zTimedeltaArray.dtypeNc                 C  s(   t |ƒ}t |jƒ ||jkr$tdƒ‚|S )Nz'Values resolution does not match dtype.)Ú_validate_td64_dtypers   Ú
ValueError)ÚclsrC   rs   rF   rF   rG   Ú_validate_dtypeÉ   s
    

zTimedeltaArray._validate_dtypeznpt.NDArray[np.timedelta64]zTick | Noner/   )rC   r]   rs   r8   c                   st   t  |d¡sJ ‚t |¡rJ ‚t|tjƒs6J t|ƒƒ‚||jksDJ ‚|d u sZt|t	ƒsZJ ‚t
ƒ j||d�}||_|S )NrP   )rC   rs   )r   rQ   r   Zis_unitlessÚ
isinstanceÚnpZndarrayÚtypers   r
   ÚsuperÚ_simple_newÚ_freq)rv   rC   r]   rs   rD   ©Ú	__class__rF   rG   r|   Ó   s    zTimedeltaArray._simple_newF©rs   ÚcopyÚbool)r�   r8   c                C  sF   |rt |ƒ}t||d d�\}}|d ur4t||dd�}| j||j|d�S )N©r�   rc   Fr€   ©rs   r]   )rt   Úsequence_to_td64nsr   r|   rs   )rv   Údatars   r�   r]   rF   rF   rG   Ú_from_sequenceå   s    zTimedeltaArray._from_sequence)rs   r�   r]   rc   c                C  sb   |rt |ƒ}|dvsJ ‚t|||d�\}}|dur@t||dd�}| j||j|d�}| |i ¡ |S )zo
        _from_sequence_not_strict but without responsibility for finding the
        result's `freq`.
        ©ÚYrp   ÚMrƒ   NFr€   r„   )rt   r…   r   r|   rs   Z_maybe_pin_freq)rv   r†   rs   r�   r]   rc   Úinferred_freqrD   rF   rF   rG   Ú_from_sequence_not_strictñ   s    z(TimedeltaArray._from_sequence_not_strict©rc   z
str | None)rc   r8   c                C  s\  t  |¡}|d u r2tdd„ |||fD ƒƒr2tdƒ‚t ||||¡dkrNtdƒ‚|d urdt|ƒ d¡}|d urzt|ƒ d¡}|d ur”|dvr˜tdƒ‚nd}|d ur¶|d ur¶|j|d	d
�}|d urÔ|d urÔ|j|d	d
�}t|ƒ\}}|d urüt	|||||d�}	nt
 |j|j|¡ d¡}	|�s&|	dd … }	|�s8|	d d… }	|	 d|› d�¡}
| j|
|
j|d�S )Nc                 s  s   | ]}|d u V  qd S rW   rF   ©Ú.0rS   rF   rF   rG   Ú	<genexpr>  rU   z1TimedeltaArray._generate_range.<locals>.<genexpr>z1Must provide freq argument if no data is suppliedé   zVOf the four parameters: start, end, periods, and freq, exactly three must be specifiedrO   )ÚsÚmsÚusrO   z+'unit' must be one of 's', 'ms', 'us', 'ns'F)Zround_okr�   rm   é   éÿÿÿÿzm8[ú]r„   )ÚdtlZvalidate_periodsÚanyru   ÚcomZcount_not_noner   rj   r   r(   ry   Zlinspacero   Úastypern   r|   rs   )rv   ÚstartÚendZperiodsr]   Úclosedrc   Zleft_closedZright_closedÚindexZ
td64valuesrF   rF   rG   Ú_generate_range  s:    
 ÿ
zTimedeltaArray._generate_rangec                 C  sP   t || jƒs|turtdƒ‚|  |¡ |tu r>t |j| j¡S | 	| j¡j
S d S )Nz'value' should be a Timedelta.)rx   rZ   r   ru   Ú_check_compatible_withry   rV   ro   rc   rj   Zasm8©rB   ÚvaluerF   rF   rG   Ú_unbox_scalar?  s    
zTimedeltaArray._unbox_scalarc                 C  s   t |ƒS rW   rX   r¢   rF   rF   rG   Ú_scalar_from_stringH  s    z"TimedeltaArray._scalar_from_stringÚNonec                 C  s   d S rW   rF   ©rB   ÚotherrF   rF   rG   r¡   K  s    z%TimedeltaArray._check_compatible_withT©r�   c                 C  sˆ   t |ƒ}t |d¡rv|| jkr.|r*|  ¡ S | S t|ƒr^t| j|dd�}t| ƒj	||j| j
d�S td| j› d|› d�ƒ‚tjj| ||d�S )NrP   Fr©   r„   zCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r!   r   rQ   rs   r�   r   r   rr   rz   r|   r]   ru   r˜   ZDatetimeLikeArrayMixinr›   )rB   rs   r�   Z
res_valuesrF   rF   rG   r›   R  s    

ÿÿzTimedeltaArray.astyper*   c           	      c  s�   | j dkr(tt| ƒƒD ]}| | V  qnd| j}t| ƒ}d}|| d }t|ƒD ]<}|| }t|d | |ƒ}t|||… dd�}|E d H  qNd S )Nr•   i'  T©Úbox)ÚndimÚrangeÚlenrr   Úminr   )	rB   Úir†   ÚlengthÚ	chunksizeÚchunksZstart_iZend_iZ	convertedrF   rF   rG   Ú__iter__m  s    
zTimedeltaArray.__iter__r   )Úaxisrs   ÚoutÚkeepdimsÚinitialÚskipnaÚ	min_countzAxisInt | NonezNpDtype | NoneÚint)rµ   rs   r·   r¹   rº   c          	      C  s6   t  d||||dœ¡ tj| j|||d�}|  ||¡S )NrF   )rs   r¶   r·   r¸   )rµ   r¹   rº   )ÚnvZvalidate_sumr$   Znansumrr   Z_wrap_reduction_result)	rB   rµ   rs   r¶   r·   r¸   r¹   rº   rD   rF   rF   rG   Úsum€  s    ÿ
ÿzTimedeltaArray.sumr•   )rµ   rs   r¶   Úddofr·   r¹   )rµ   rs   r¾   r·   r¹   c                C  sR   t jd|||dœdd� tj| j|||d�}|d u s>| jdkrH|  |¡S |  |¡S )NrF   )rs   r¶   r·   Ústd)Úfname)rµ   r¹   r¾   r•   )r¼   Zvalidate_stat_ddof_funcr$   Znanstdrr   r¬   rq   Z_from_backing_data)rB   rµ   rs   r¶   r¾   r·   r¹   rD   rF   rF   rG   r¿   ”  s    
ÿ
zTimedeltaArray.std)r¹   r3   )r4   r¹   c                  sp   |dkrBt t|ƒ}|| j ¡ fd|i|¤Ž}t| ƒj|d | jd�S |dkrTtdƒ‚ntƒ j	|fd|i|¤ŽS d S )NZcumsumr¹   )r]   rs   Zcumprodz$cumprod not supported for Timedelta.)
Úgetattrr&   rr   r�   rz   r|   rs   Ú	TypeErrorr{   Ú_accumulate)rB   r4   r¹   ÚkwargsÚoprD   r~   rF   rG   rÃ   ª  s    

zTimedeltaArray._accumulate)Úboxedc                 C  s   ddl m} || dd�S )Nr   ©Úget_format_timedelta64Trª   )Úpandas.io.formats.formatrÈ   )rB   rÆ   rÈ   rF   rF   rG   Ú
_formatter¹  s    zTimedeltaArray._formatter)Úna_repÚdate_formatzstr | floatznpt.NDArray[np.object_])rË   r8   c                K  s*   ddl m} || |ƒ}t |dd¡| jƒS )Nr   rÇ   r•   )rÉ   rÈ   ry   Z
frompyfuncrr   )rB   rË   rÌ   rÄ   rÈ   Ú	formatterrF   rF   rG   Ú_format_native_types¾  s    
z#TimedeltaArray._format_native_typesc                 C  s2   t |tƒrJ ‚tdt|ƒj› dt| ƒj› �ƒ‚d S )Nzcannot add the type z to a )rx   r
   rÂ   rz   rJ   r§   rF   rF   rG   Ú_add_offsetÌ  s    ÿzTimedeltaArray._add_offsetÚ__mul__c                   s:  t ˆƒrv| jˆ }|jjdkr2tdtˆƒj› �ƒ‚d }| jd ur`tˆƒs`| jˆ }|j	dkr`d }t| ƒj
||j|d�S tˆdƒsŠt ˆ¡‰tˆƒt| ƒkr°t ˆjd¡s°tdƒ‚tˆjƒrú| j‰ ‡ ‡fdd„tt| ƒƒD ƒ}t |¡}t| ƒj
||jd	�S | jˆ }|jjdk�r&tdtˆƒj› �ƒ‚t| ƒj
||jd	�S )
NrP   zCannot multiply with r   r„   rs   z$Cannot multiply with unequal lengthsc                   s   g | ]}ˆ | ˆ|  ‘qS rF   rF   ©r�   Ún©Zarrr¨   rF   rG   Ú
<listcomp>ð  rU   z*TimedeltaArray.__mul__.<locals>.<listcomp>©rs   )r   rr   rs   ÚkindrÂ   rz   rJ   r]   r#   rÒ   r|   Úhasattrry   Úarrayr®   r   rQ   ru   r   r­   )rB   r¨   rD   r]   rF   rÓ   rG   rÐ   Ò  s.    







zTimedeltaArray.__mul__c                 C  sØ   t || jƒrPt|ƒ}td|ƒtu rDtj| jtjd�}| 	tj
¡ |S || j|ƒS |tjtjfv r€tdt|ƒj› dt| ƒj› �ƒ‚|| j|ƒ}d}| jdur¾| j| }|jdkr¾| jjdkr¾d}t| ƒj||j|d�S dS )zv
        Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__
        with scalar 'other'.
        rl   rÕ   zCannot divide z by Nr   r„   )rx   Ú_recognized_scalarsr   r   r   ry   ÚemptyÚshaper;   ÚfillÚnanrr   r%   ÚrtruedivÚ	rfloordivrÂ   rz   rJ   r]   Znanosr|   rs   )rB   r¨   rÅ   ÚresrD   r]   rF   rF   rG   Ú_scalar_divlike_opþ  s$    ÿ

z!TimedeltaArray._scalar_divlike_opc                 C  s0   t |dƒst |¡}t|ƒt| ƒkr,tdƒ‚|S )Nrs   z*Cannot divide vectors with unequal lengths)r×   ry   rØ   r®   ru   r§   rF   rF   rG   Ú_cast_divlike_op'  s
    

zTimedeltaArray._cast_divlike_opznp.ndarray | Selfc                 C  s’   || j t |¡ƒ}t|jƒs&t|jƒrJ|tjtjfv rJt	| ƒj
||jd�S |tjtjfv rŽ|  ¡ t|ƒB }| ¡ rŽ| tj¡}t ||tj¡ |S )z‡
        Shared logic for __truediv__, __floordiv__, and their reversed versions
        with timedelta64-dtype ndarray other.
        rÕ   )rr   ry   Úasarrayr   rs   r   ÚoperatorÚtruedivÚfloordivrz   r|   r%   rß   r#   r™   r›   r;   ZputmaskrÝ   )rB   r¨   rÅ   rD   ÚmaskrF   rF   rG   Ú_vector_divlike_op0  s    þz!TimedeltaArray._vector_divlike_opÚ__truediv__c                 C  sº   t j}t|ƒr|  ||¡S |  |¡}t |jd¡sFt|jƒsFt	|jƒrR|  
||¡S t|jƒr²t |¡}| jdkr¢dd„ t| |ƒD ƒ}dd„ |D ƒ}tj|dd�}nt| j|ƒ}|S tS d S )NrP   r•   c                 S  s   g | ]\}}|| ‘qS rF   rF   ©r�   ÚleftÚrightrF   rF   rG   rÔ   X  rU   z.TimedeltaArray.__truediv__.<locals>.<listcomp>c                 S  s   g | ]}|  d d¡‘qS ©r•   r–   ©ZreshaperŽ   rF   rF   rG   rÔ   Y  rU   r   ©rµ   )rä   rå   r   rá   râ   r   rQ   rs   r   r   rè   r   ry   rã   r¬   ÚzipÚconcatenater   rr   ÚNotImplemented©rB   r¨   rÅ   Zres_colsZ	res_cols2rD   rF   rF   rG   ré   F  s(    
ÿþý


zTimedeltaArray.__truediv__Ú__rtruediv__c                   sv   t j}tˆ ƒrˆ ˆ |¡S ˆ ˆ ¡‰ t ˆ jd¡r>ˆ ˆ |¡S t	ˆ jƒrn‡ ‡fdd„t
tˆƒƒD ƒ}t |¡S tS d S )NrP   c                   s   g | ]}ˆ | ˆ|  ‘qS rF   rF   rÑ   ©r¨   rB   rF   rG   rÔ   r  rU   z/TimedeltaArray.__rtruediv__.<locals>.<listcomp>)r%   rÞ   r   rá   râ   r   rQ   rs   rè   r   r­   r®   ry   rØ   rò   )rB   r¨   rÅ   Úresult_listrF   rõ   rG   rô   c  s    


zTimedeltaArray.__rtruediv__Ú__floordiv__c                 C  sÈ   t j}t|ƒr|  ||¡S |  |¡}t |jd¡sFt|jƒsFt	|jƒrR|  
||¡S t|jƒrÀt |¡}| jdkr¢dd„ t| |ƒD ƒ}dd„ |D ƒ}tj|dd�}nt| j|ƒ}|jtks¼J ‚|S tS d S )NrP   r•   c                 S  s   g | ]\}}|| ‘qS rF   rF   rê   rF   rF   rG   rÔ   ‰  rU   z/TimedeltaArray.__floordiv__.<locals>.<listcomp>c                 S  s   g | ]}|  d d¡‘qS rí   rî   rŽ   rF   rF   rG   rÔ   Š  rU   r   rï   )rä   ræ   r   rá   râ   r   rQ   rs   r   r   rè   r   ry   rã   r¬   rð   rñ   r   rr   Úobjectrò   ró   rF   rF   rG   r÷   x  s*    
ÿþý


zTimedeltaArray.__floordiv__Ú__rfloordiv__c                   sz   t j}tˆ ƒrˆ ˆ |¡S ˆ ˆ ¡‰ t ˆ jd¡r>ˆ ˆ |¡S t	ˆ jƒrr‡ ‡fdd„t
tˆƒƒD ƒ}t |¡}|S tS d S )NrP   c                   s   g | ]}ˆ | ˆ|  ‘qS rF   rF   rÑ   rõ   rF   rG   rÔ      rU   z0TimedeltaArray.__rfloordiv__.<locals>.<listcomp>)r%   rß   r   rá   râ   r   rQ   rs   rè   r   r­   r®   ry   rØ   rò   )rB   r¨   rÅ   rö   rD   rF   rõ   rG   rù   •  s    


zTimedeltaArray.__rfloordiv__Ú__mod__c                 C  s$   t || jƒrt|ƒ}| | | |  S rW   ©rx   rÙ   r   r§   rF   rF   rG   rú   §  s    zTimedeltaArray.__mod__Ú__rmod__c                 C  s$   t || jƒrt|ƒ}|||  |   S rW   rû   r§   rF   rF   rG   rü   ®  s    zTimedeltaArray.__rmod__Ú
__divmod__c                 C  s0   t || jƒrt|ƒ}| | }| ||  }||fS rW   rû   ©rB   r¨   Zres1Zres2rF   rF   rG   rý   µ  s
    zTimedeltaArray.__divmod__Ú__rdivmod__c                 C  s0   t || jƒrt|ƒ}||  }|||   }||fS rW   rû   rþ   rF   rF   rG   rÿ   ¿  s
    zTimedeltaArray.__rdivmod__c                 C  s0   d }| j d ur| j  }t| ƒj| j | j|d�S ©Nr„   )r]   rz   r|   rr   rs   )rB   r]   rF   rF   rG   Ú__neg__É  s    
zTimedeltaArray.__neg__c                 C  s   t | ƒj| j ¡ | j| jd�S r   )rz   r|   rr   r�   rs   r]   rY   rF   rF   rG   Ú__pos__Ï  s    ÿzTimedeltaArray.__pos__c                 C  s   t | ƒjt | j¡| jd�S )NrÕ   )rz   r|   ry   Úabsrr   rs   rY   rF   rF   rG   Ú__abs__Ô  s    zTimedeltaArray.__abs__znpt.NDArray[np.float64]c                 C  s   t | jƒ}| j| j| d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?   rA   r>   )rB   ZppsrF   rF   rG   rf   Û  s    6
zTimedeltaArray.total_secondsc                 C  s
   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   rr   rY   rF   rF   rG   re     s    zTimedeltaArray.to_pytimedeltaaC  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')r9   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')r_   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')r`   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')ra   r2   c                   s`   ddl m} g d¢‰ | j}|r,‡ fdd„‰ndd„ ‰|‡fdd„| D ƒˆ d	�}|s\| d
¡}|S )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   r1   )r9   ÚhoursÚminutesr_   Zmillisecondsr`   ra   c                   s   t | ƒrtjgtˆ ƒ S | jS rW   )r#   ry   rÝ   r®   Ú
componentsrR   ©ÚcolumnsrF   rG   rH   Ò  s    z$TimedeltaArray.components.<locals>.fc                 S  s   | j S rW   )r  rR   rF   rF   rG   rH   Ù  s    c                   s   g | ]}ˆ |ƒ‘qS rF   rF   rŽ   )rH   rF   rG   rÔ   Ü  rU   z-TimedeltaArray.components.<locals>.<listcomp>r  Úint64)Úpandasr2   r@   r›   )rB   r2   ZhasnansrD   rF   )r	  rH   rG   r  ®  s    	
zTimedeltaArray.components)N)T)F)OrJ   Ú
__module__Ú__qualname__rK   Z_typry   rV   Z_internal_fill_valuer   r
   rÙ   Z_is_recognized_dtypeZ_infer_matchesrL   rZ   Z__array_priority__r[   Ú__annotations__r\   r^   rb   rd   rk   rq   rs   r}   r   Z_default_dtypeÚclassmethodrw   r|   r‡   r   Z
no_defaultrŒ   r    r¤   r¥   r¡   r›   r´   r½   r¿   rÃ   rÊ   rÎ   rÏ   r)   rÐ   Ú__rmul__rá   râ   rè   ré   rô   r÷   rù   rú   rü   rý   rÿ   r  r  r  rf   re   ÚtextwrapÚdedentZdays_docstringrM   r9   Zseconds_docstringr_   Zmicroseconds_docstringr`   Znanoseconds_docstringra   r  Ú__classcell__rF   rF   r~   rG   rN   g   sò   
%
	üù ÿÿ0	÷øÿ))	






	
	9ÿÿýÿýÿýrN   FÚraiser‚   r,   ztuple[np.ndarray, Tick | None])r�   Úerrorsr8   c                 C  s|  |dvsJ ‚d}|dur t |ƒ}tj| |dd�\} }t| tƒrD| j}| jtksXt| jƒrlt	| ||d�} d}nÆt
| jƒr’t| |d�\} }|oŽ| }n t| jƒræt| jtƒr¶| j}| j} n
t | ¡}t| |pÊdƒ} t| |< |  d	¡} d}nLt | jd
¡�r t| jƒ�s2t| jƒ}t| |dd�} d}ntd| j› d�ƒ‚|�sDt | ¡} ntj| |d�} | jjd
k�sdJ ‚| jdk�stJ ‚| |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ˆ   NrN   )Úcls_name©rc   r  Fr�   rO   zm8[ns]rP   r€   zdtype z' cannot be converted to timedelta64[ns]r©   Úm8)r   r˜   Z!ensure_arraylike_for_datetimelikerx   rN   r]   rs   rø   r    Ú_objects_to_td64nsr   Ú_ints_to_td64nsr   r"   Z_maskÚ_datary   Úisnanr   r   rn   r   rQ   r   r   r   rÂ   rã   rØ   rÖ   )r†   r�   rc   r  r‹   Ú	copy_maderç   Z	new_dtyperF   rF   rG   r…   æ  sH    $ÿ






r…   rO   r�   c                 C  sr   d}|dur|nd}| j tjkr0|  tj¡} d}|dkr`d|› d�}|  |¡} t| td�} d}n
|  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
    FNrO   Tztimedelta64[r—   rÕ   útimedelta64[ns])rs   ry   r
  r›   rn   r   r   )r†   rc   r  Z	dtype_strrF   rF   rG   r  F  s    

r  )r  c                 C  s(   t j| t jd�}t|||d�}| 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Õ   r  r  )ry   rã   Zobject_r   rn   )r†   rc   r  rC   rD   rF   rF   rG   r  n  s    r  r-   r7   c                 C  sT   t | ƒ} | t d¡kr"d}t|ƒ‚t | d¡s@td| › d�ƒ‚nt| ƒsPtdƒ‚| S )Nr  zhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rP   zdtype 'z,' is invalid, should be np.timedelta64 dtypez;Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns')r!   ry   rs   ru   r   rQ   r   )rs   ÚmsgrF   rF   rG   rt   ’  s    ÿrt   )FNr  )rO   )Nr  )VÚ
__future__r   Údatetimer   rä   Útypingr   r   Únumpyry   Zpandas._libsr   r   Zpandas._libs.tslibsr   r	   r
   r   r   r   r   r   r   Zpandas._libs.tslibs.conversionr   Zpandas._libs.tslibs.fieldsr   r   Zpandas._libs.tslibs.timedeltasr   r   r   r   r   Zpandas.compat.numpyr   r¼   Zpandas.util._validatorsr   Zpandas.core.dtypes.commonr   r   r   r   r   r    r!   Zpandas.core.dtypes.dtypesr"   Zpandas.core.dtypes.missingr#   Zpandas.corer$   r%   Zpandas.core.array_algosr&   Zpandas.core.arraysr'   r˜   Zpandas.core.arrays._rangesr(   Zpandas.core.commonÚcoreÚcommonrš   Zpandas.core.ops.commonr)   Úcollections.abcr*   Zpandas._typingr+   r,   r-   r.   r/   r0   r  r2   r  rM   ZTimelikeOpsrN   r…   r  r  rt   rF   rF   rF   rG   Ú<module>   sR   ,$	 	          ü`($