U
    MZfш                     @  s  d dl mZ d dlmZ d dlZd dl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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 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)m*Z*m+Z+m,Z,m-Z- d dl.m/Z0 d dl1m2Z2 d dl3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z= d dl>m?Z? d dl@mAZA d dlBmCZC d dlDmEZF d dlGmHZH d dlImJ  mKZL d dlMmNZN d dlOmPZP erd dlQmRZR ddddddZSG dd deFjTZUd/ddd d!d"d#ZVd0dd%d&d'ZWd1dd(d)d*ZXd+d,d-d.ZYdS )2    )annotations)	timedeltaN)TYPE_CHECKINGIteratorcast)libtslibs)
BaseOffsetNaTNaTTypeTick	Timedeltaastype_overflowsafeget_supported_resoget_unit_from_dtypeiNaTis_supported_unitnpy_unit_to_abbrevperiods_per_second	to_offset)precision_from_unit)get_timedelta_daysget_timedelta_field)array_to_timedelta64floordiv_object_arrayints_to_pytimedeltaparse_timedelta_unittruediv_object_array)AxisIntDateTimeErrorChoicesDtypeObjNpDtypenpt)function)validate_endpoints)
TD64NS_DTYPEis_dtype_equalis_extension_array_dtypeis_float_dtypeis_integer_dtypeis_object_dtype	is_scalaris_string_dtypeis_timedelta64_dtypepandas_dtype)isna)nanops)datetimelike_accumulations)datetimelike)generate_regular_range)	roperator)unpack_zerodim_and_defer	DataFramestr)namealias	docstringc                   s.   dd fdd}| |_ d| d|_t|S )N
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r:    A/tmp/pip-unpacked-wheel-nbcvw55c/pandas/core/arrays/timedeltas.pyfR   s      z_field_accessor.<locals>.f
)__name____doc__property)r9   r:   r;   rN   rL   rK   rM   _field_accessorQ   s    rS   c                      s  e Zd ZU dZdZeddZeeje	fZ
e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< ddddgZded< ee e dg Zded< ddddddg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+ fd,d-Zed&d.d/d0d d1d2d3Z ed&d.e!j"d&d4d0d d1d5d6Z#edd&d7d8d7d9d:Z$ddd;d<Z%ddd=d>Z&d?dd@dAZ'dd0dCdDdEZ(dFddGdHZ)d&d&d&d.d&dBdIdJdKdLd0d0dMdNdOdPZ*d&d&d&dQd.dBdRdKdLdMd0d0dSdTdUZ+dBdVdWd0dX fdYdZZ,dd0d[d\d]Z-dd&d^d_d`dadbdcZ.ddde Z/e0dfd ddgdhZ1e1Z2didj Z3dkdl Z4dmddndoZ5e0dpdqdr Z6e0dsdtdu Z7e0dvdwdx Z8e0dydzd{ Z9e0d|d}d~ Z:e0ddd Z;e0ddd Z<e0ddd Z=d dddZ>d dddZ?d dddZ@ddddZAd`dddZBeCdddZDeCdddZEeCdddZFeCdddZGeddddZH  ZIS )TimedeltaArraya  
    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
    Ztimedeltaarrayr
   ns)r   timedelta64ztype[Timedelta]r=   c                 C  s   t S Nr   rH   rL   rL   rM   _scalar_type   s    zTimedeltaArray._scalar_typei  z	list[str]
_other_ops	_bool_opsfreq_object_opsr?   secondsmicrosecondsnanoseconds
_field_opsunit_datetimelike_opsto_pytimedeltatotal_secondsroundfloorceilas_unit_datetimelike_methodsznp.timedelta64Timedelta | NaTType)xr>   c                 C  s(   | d}|tjkrtS tj|| jdS )Ni8r@   )viewr
   _valuer   Z_from_value_and_resorE   )rH   rm   yrL   rL   rM   	_box_func   s    

zTimedeltaArray._box_funcznp.dtypec                 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   rL   rL   rM   rt      s    zTimedeltaArray.dtypeNc                 C  s   t |j t |}|S rW   )_validate_td64_dtypert   )clsrI   rt   rL   rL   rM   _validate_dtype   s    
zTimedeltaArray._validate_dtyper<   zBaseOffset | None)rI   r]   r>   c                   sh   t |tjr|jdkstt|r(tt |tjs@tt|||jksNtt	 j
||d}||_|S )Nm)rI   rt   )
isinstancenprt   kindAssertionErrorr   Zis_unitlessZndarraytypesuper_simple_new_freq)rv   rI   r]   rt   rJ   	__class__rL   rM   r      s    zTimedeltaArray._simple_newFrt   copybool)r   r>   c                C  sX   |rt |}t||d d\}}td |d\}}|d k	rFt||dd}| j||j|dS )Nr   rc   Fr   rt   r]   )ru   sequence_to_td64nsdtlvalidate_inferred_freqr   r   rt   )rv   datart   r   inferred_freqr]   _rL   rL   rM   _from_sequence   s    zTimedeltaArray._from_sequence)rt   r   r]   rc   c          
      C  s   |rt |}|dkst|dk}|tjk	r.|nd}t|\}}t|||d\}}t|||\}}|rld}|dk	rt||dd}| j	||j
|d}	|dkr|dk	r| |	| n|rt|	j|	_|	S )z]
        A non-strict version of _from_sequence, called from TimedeltaIndex.__new__.
        Yrq   MNr   Fr   r   )ru   r|   r   
no_defaultr   Zmaybe_infer_freqr   r   r   r   rt   Z_validate_frequencyr   r   r   )
rv   r   rt   r   r]   rc   Zexplicit_noneZ
freq_inferr   rJ   rL   rL   rM   _from_sequence_not_strict   s$    z(TimedeltaArray._from_sequence_not_strictrc   z
str | Nonec                C  s\  t |}|d kr2tdd |||fD r2tdt||||dkrNtd|d k	rdt|d}|d k	rzt|d}|d k	r|dkrtdnd}|d k	r|d k	r|j|d	d
}|d k	r|d k	r|j|d	d
}t|\}}|d k	rt	|||||d}	nt
|j|j|d}	|s&|	dd  }	|s8|	d d }	|	d| d}
| j|
|
j|dS )Nc                 s  s   | ]}|d kV  qd S rW   rL   .0rm   rL   rL   rM   	<genexpr>  s     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 specifiedrU   )smsusrU   z+'unit' must be one of 's', 'ms', 'us', 'ns'F)Zround_okr   rn      m8[]r   )r   Zvalidate_periodsany
ValueErrorcomZcount_not_noner   rj   r$   r3   rz   Zlinspacerp   astypero   r   rt   )rv   startendZperiodsr]   closedrc   Zleft_closedZright_closedindexZ
td64valuesrL   rL   rM   _generate_range  s:    
 
zTimedeltaArray._generate_rangec                 C  sP   t || js|tk	rtd| | |tkr>t|j| jS |	| jj
S d S )Nz'value' should be a Timedelta.)ry   rZ   r
   r   _check_compatible_withrz   rV   rp   rc   rj   Zasm8rH   valuerL   rL   rM   _unbox_scalarD  s    
zTimedeltaArray._unbox_scalarc                 C  s   t |S rW   rX   r   rL   rL   rM   _scalar_from_stringM  s    z"TimedeltaArray._scalar_from_stringNonec                 C  s   d S rW   rL   rH   otherrL   rL   rM   r   P  s    z%TimedeltaArray._check_compatible_withTr   c                 C  s   t |}t|tjr|jdkr|| jkr8|r4|  S | S tt|rlt| j	|dd}t
| j||j| jdS td| j d| dtjj| ||dS )Nrx   Fr   r   zCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r.   ry   rz   rt   r{   r   r   r   r   rs   r}   r   r]   r   r   ZDatetimeLikeArrayMixinr   )rH   rt   r   Z
res_valuesrL   rL   rM   r   W  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Zbox)ndimrangelenrs   minr   )	rH   ir   length	chunksizechunksZstart_iZend_iZ	convertedrL   rL   rM   __iter__r  s    
zTimedeltaArray.__iter__r   )axisrt   outkeepdimsinitialskipna	min_countzAxisInt | NonezNpDtype | Noneint)r   rt   r   r   r   c          	      C  s6   t d||||d tj| j|||d}| ||S )NrL   )rt   r   r   r   )r   r   r   )nvZvalidate_sumr0   Znansumrs   Z_wrap_reduction_result)	rH   r   rt   r   r   r   r   r   rJ   rL   rL   rM   sum  s        zTimedeltaArray.sumr   )r   rt   r   ddofr   r   )r   rt   r   r   r   c                C  sR   t jd|||ddd tj| j|||d}|d ks>| jdkrH| |S | |S )NrL   )rt   r   r   std)fname)r   r   r   r   )r   Zvalidate_stat_ddof_funcr0   Znanstdrs   r   rr   Z_from_backing_data)rH   r   rt   r   r   r   r   rJ   rL   rL   rM   r     s    
 
 
zTimedeltaArray.std)r   r8   )r9   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]   rt   Zcumprodz$cumprod not supported for Timedelta.)
getattrr1   rs   r   r}   r   rt   	TypeErrorr~   _accumulate)rH   r9   r   kwargsoprJ   r   rL   rM   r     s    

zTimedeltaArray._accumulate)boxedc                 C  s   ddl m} || ddS )Nr   get_format_timedelta64Tr   )pandas.io.formats.formatr   )rH   r   r   rL   rL   rM   
_formatter  s    zTimedeltaArray._formatter)na_repdate_formatzstr | floatznpt.NDArray[np.object_])r   r>   c                K  s,   ddl m} || j|}t|dd| jS )Nr   r   r   )r   r   rs   rz   Z
frompyfunc)rH   r   r   r   r   	formatterrL   rL   rM   _format_native_types  s    z#TimedeltaArray._format_native_typesc                 C  s2   t |trttdt|j dt| j d S )Nzcannot add the type z to a )ry   r   r|   r   r}   rP   r   rL   rL   rM   _add_offset  s    zTimedeltaArray._add_offset__mul__c                   s   t rH| j }d }| jd k	r2ts2| j }t| j||j|dS tds\t	t
t
| kr~tjs~tdtjr| j  fddtt
| D }t	|}t| j||jdS | j }t| j||jdS )Nr   rt   z$Cannot multiply with unequal lengthsc                   s   g | ]} | |  qS rL   rL   r   nZarrr   rL   rM   
<listcomp>  s     z*TimedeltaArray.__mul__.<locals>.<listcomp>rt   )r+   rs   r]   r/   r}   r   rt   hasattrrz   arrayr   r-   r   r*   r   )rH   r   rJ   r]   rL   r   rM   r     s"    






zTimedeltaArray.__mul__c                 C  s   t || jrPt|}td|tkrDtj| jtjd}|	tj
 |S || j|S |tjtjfkrtdt|j dt| j || j|}d}| jdk	r| j| }|tjkr|jdkr| jjdkrd}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   )ry   _recognized_scalarsr   r   r
   rz   emptyshaperA   fillnanrs   r4   rtruediv	rfloordivr   r}   rP   r]   operatorfloordivZnanosr   rt   )rH   r   r   rJ   r]   rL   rL   rM   _scalar_divlike_op  s&    


z!TimedeltaArray._scalar_divlike_opc                 C  s0   t |dst|}t|t| kr,td|S )Nrt   z*Cannot divide vectors with unequal lengths)r   rz   r   r   r   r   rL   rL   rM   _cast_divlike_op(  s
    

zTimedeltaArray._cast_divlike_opznp.ndarray | TimedeltaArrayc                 C  s   || j t|}t|js&t|jrJ|tjtjfkrJt	| j
||jdS |tjtjfk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   )rs   rz   asarrayr)   rt   r(   r   truedivr   r}   r   r4   r   r/   r   r   rA   Zputmaskr   )rH   r   r   rJ   maskrL   rL   rM   _vector_divlike_op1  s    z!TimedeltaArray._vector_divlike_op__truediv__c                 C  s   t j}t|r| ||S | |}t|jsBt|jsBt|jrN| 	||S t
|jrt|}| jdkrdd t| |D }dd |D }tj|dd}nt| j|}|S tS d S )Nr   c                 S  s   g | ]\}}|| qS rL   rL   r   leftrightrL   rL   rM   r   Y  s     z.TimedeltaArray.__truediv__.<locals>.<listcomp>c                 S  s   g | ]}| d dqS r   r   Zreshaper   rL   rL   rM   r   Z  s     r   r   )r   r   r+   r   r   r-   rt   r)   r(   r   r*   rz   r   r   zipconcatenater   rs   NotImplementedrH   r   r   Zres_colsZ	res_cols2rJ   rL   rL   rM   r   G  s(    



zTimedeltaArray.__truediv____rtruediv__c                   sr   t j}t r |S   t jr: |S t jrj fddt	t
D }t|S tS d S )Nc                   s   g | ]} | |  qS rL   rL   r   r   rH   rL   rM   r   s  s     z/TimedeltaArray.__rtruediv__.<locals>.<listcomp>)r4   r   r+   r   r   r-   rt   r   r*   r   r   rz   r   r   )rH   r   r   result_listrL   r   rM   r   d  s    



zTimedeltaArray.__rtruediv____floordiv__c                 C  s   t j}t|r| ||S | |}t|jsBt|jsBt|jrN| 	||S t
|jrt|}| jdkrdd t| |D }dd |D }tj|dd}nt| j|}|jtkst|S tS d S )Nr   c                 S  s   g | ]\}}|| qS rL   rL   r   rL   rL   rM   r     s     z/TimedeltaArray.__floordiv__.<locals>.<listcomp>c                 S  s   g | ]}| d dqS r   r   r   rL   rL   rM   r     s     r   r   )r   r   r+   r   r   r-   rt   r)   r(   r   r*   rz   r   r   r   r   r   rs   objectr|   r   r   rL   rL   rM   r   y  s*    



zTimedeltaArray.__floordiv____rfloordiv__c                   sv   t j}t r |S   t jr: |S t jrn fddt	t
D }t|}|S tS d S )Nc                   s   g | ]} | |  qS rL   rL   r   r   rL   rM   r     s     z0TimedeltaArray.__rfloordiv__.<locals>.<listcomp>)r4   r   r+   r   r   r-   rt   r   r*   r   r   rz   r   r   )rH   r   r   r   rJ   rL   r   rM   r     s    



zTimedeltaArray.__rfloordiv____mod__c                 C  s$   t || jrt|}| | | |  S rW   ry   r   r   r   rL   rL   rM   r     s    zTimedeltaArray.__mod____rmod__c                 C  s$   t || jrt|}|||  |   S rW   r   r   rL   rL   rM   r    s    zTimedeltaArray.__rmod__
__divmod__c                 C  s0   t || jrt|}| | }| ||  }||fS rW   r   rH   r   Zres1Zres2rL   rL   rM   r    s
    zTimedeltaArray.__divmod____rdivmod__c                 C  s0   t || jrt|}||  }|||   }||fS rW   r   r  rL   rL   rM   r    s
    zTimedeltaArray.__rdivmod__c                 C  s0   d }| j d k	r| j  }t| j| j | j|dS )Nr   )r]   r}   r   rs   rt   )rH   r]   rL   rL   rM   __neg__  s    
zTimedeltaArray.__neg__c                 C  s   t | | j | jdS )N)r]   )r}   rs   r   r]   rY   rL   rL   rM   __pos__  s    zTimedeltaArray.__pos__c                 C  s   t | t| jS rW   )r}   rz   absrs   rY   rL   rL   rM   __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)rB   )r   rE   rG   rD   )rH   ZppsrL   rL   rM   rf     s    6
zTimedeltaArray.total_secondsc                 C  s
   t | jS )zy
        Return an ndarray of datetime.timedelta objects.

        Returns
        -------
        numpy.ndarray
        )r   rs   rY   rL   rL   rM   re     s    zTimedeltaArray.to_pytimedeltaz Number of days for each element.z>Number of seconds (>= 0 and less than 1 day) for each element.zFNumber of microseconds (>= 0 and less than 1 second) for each element.zJNumber of nanoseconds (>= 0 and less than 1 microsecond) for each element.r7   c                   sj   ddl m} ddddddd	g | j}|r6 fd
dndd |fdd| D  d}|sf|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
        r   r6   r?   hoursminutesr_   Zmillisecondsr`   ra   c                   s   t | rtjgt  S | jS rW   )r/   rz   r   r   
componentsrm   columnsrL   rM   rN   H  s    z$TimedeltaArray.components.<locals>.fc                 S  s   | j S rW   )r  r  rL   rL   rM   rN   O  s    c                   s   g | ]} |qS rL   rL   r   )rN   rL   rM   r   R  s     z-TimedeltaArray.components.<locals>.<listcomp>r  int64)pandasr7   rF   r   )rH   r7   ZhasnansrJ   rL   )r  rN   rM   r  .  s"    	
zTimedeltaArray.components)N)T)F)JrP   
__module____qualname__rQ   Z_typrz   rV   Z_internal_fill_valuer   r   r   r-   Z_is_recognized_dtypeZ_infer_matchesrR   rZ   Z__array_priority__r[   __annotations__r\   r^   rb   rd   rk   rr   rt   r   r%   Z_default_dtypeclassmethodrw   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r5   r   __rmul__r   r   r   r   r   r   r   r   r  r  r  r  r  r  rf   re   rS   r?   r_   r`   ra   r  __classcell__rL   rL   r   rM   rT   g   s   

 - 0	 0	






	
	9
rT   Fraiser   r   ztuple[np.ndarray, Tick | None])r   errorsr>   c              	   C  s  |dkst d}|dk	r t|}tj| |dd\} }t| trD| j}t| jsXt	| jrnt
| ||d} d}nbt| jrt| |d\} }|o| }n:t| jrht| r| j}| j} n
t| }t|pd\}}t   td	d
t | tj}	W 5 Q R X | |	 }
|rt|
|}
t 2 td	d
t |	| |
| tj d} W 5 Q R X t| |< d}nht| jrt| j}t|st |}t!|}td| d}t"| |dd} d}nt#d| j dtj$| |d} | jj%dkst | jdks t | |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   NrT   )Zcls_namerc   r  Fr   rU   ignorez!invalid value encountered in casttimedelta64[ns]r   r   r   dtype ' cannot be converted to timedelta64[ns]r   rx   Zm8)&r|   r   r   Z!ensure_arraylike_for_datetimelikery   rT   r]   r*   rt   r,   _objects_to_td64nsr)   _ints_to_td64nsr(   r'   Z_mask_datarz   isnanr   warningscatch_warningsfilterwarningsRuntimeWarningr   r  rg   ro   r   r-   r   r   r   r   r   r   r   r{   )r   r   rc   r  r   	copy_mader   rx   pbasefracZ	data_unitZnew_resoZnew_unitZ	new_dtyperL   rL   rM   r   \  sn    $  




  
  (

r   rU   r   c                 C  sr   d}|dk	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
    FNrU   Tztimedelta64[r   r   r  )rt   rz   r  r   ro   r   r%   )r   rc   r&  Z	dtype_strrL   rL   rM   r    s    

r  )r  c                 C  s*   t j| t jd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.
    Fr   r  r  )rz   r   Zobject_r   ro   )r   rc   r  rI   rJ   rL   rL   rM   r    s    r  r    r=   c                 C  sZ   t | } t| tdr$d}t|t| tjrF| jdksFtt| sVtd|  d| S )NrV   zhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rx   r  r  )	r.   r&   rz   rt   r   ry   r{   r   r   )rt   msgrL   rL   rM   ru     s    

ru   )FNr  )rU   )Nr  )Z
__future__r   datetimer   r   typingr   r   r   r"  Znumpyrz   Zpandas._libsr   r   Zpandas._libs.tslibsr	   r
   r   r   r   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._typingr   r   r    r!   r"   Zpandas.compat.numpyr#   r   Zpandas.util._validatorsr$   Zpandas.core.dtypes.commonr%   r&   r'   r(   r)   r*   r+   r,   r-   r.   Zpandas.core.dtypes.missingr/   Zpandas.corer0   Zpandas.core.array_algosr1   Zpandas.core.arraysr2   r   Zpandas.core.arrays._rangesr3   Zpandas.core.commoncorecommonr   Zpandas.core.opsr4   Zpandas.core.ops.commonr5   r  r7   rS   ZTimelikeOpsrT   r   r  r  ru   rL   rL   rL   rM   <module>   sL   <0     |   m($