U
    f/el                     @  s  d dl mZ d dlmZ d dlmZ d dlZd dlm	Z	m
Z
 d dlmZ d dlmZmZmZmZmZmZmZmZmZ d dlmZmZ d d	lmZ d d
lmZmZmZ d dl m!Z!m"Z" d dl#m$Z% d dl&m'Z' d dl(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2 d dl3m4Z4 d dl5m6Z6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z= d dl>m?Z?m@Z@mAZB d dlCmDZD d dlEmF  mGZH d dlImJZJ d dlKmLZL erd dlMmNZN d dl>mOZOmPZP ddddddZQG dd deBjRZSd0d"d#d$d%d&ZTd1d(d)ZUd2d*d+ZVd,d-d.d/ZWdS )3    )annotations)	timedelta)TYPE_CHECKINGN)libtslibs)NDArrayBacked)	
BaseOffsetNaTNaTTypePeriodTick	Timedelta	TimestampiNaT	to_offset)ensure_timedelta64nsprecision_from_unit)get_timedelta_field)array_to_timedelta64ints_to_pytimedeltaparse_timedelta_unit)DtypeObjNpDtype)function)astype_td64_unit_conversion)
DT64NS_DTYPETD64NS_DTYPEis_dtype_equalis_float_dtypeis_integer_dtypeis_object_dtype	is_scalaris_string_dtypeis_timedelta64_dtypepandas_dtype)DatetimeTZDtype)ABCCategoricalABCMultiIndex)isna)nanops)checked_add_with_arr)ExtensionArrayIntegerArraydatetimelike)generate_regular_range)extract_array)unpack_zerodim_and_defer	DataFrame)DatetimeArrayPeriodArraystr)namealias	docstringc                   s.   dd fdd}| |_ d| d|_t|S )N
np.ndarrayreturnc                   s*   | j }t| }| jr&| j|d dd}|S )Nfloat64)
fill_valueconvert)asi8r   _hasnans_maybe_mask_results)selfvaluesresultr7    A/tmp/pip-unpacked-wheel-tiezk1ph/pandas/core/arrays/timedeltas.pyfQ   s    
  z_field_accessor.<locals>.f
)__name____doc__property)r6   r7   r8   rH   rF   rE   rG   _field_accessorP   s    
rM   c                      sZ  e Zd ZU dZdZeZeej	e
fZeZ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 Zded< dddddgZded< ddddZeddddZdZeejdfdd d!d"Zedefd#d$d d% fd&d'Z eedd(dd d)d*d+Z!eedejdfdd d)d,d-Z"edd.d/Z#ddd0d1d2d3Z$ddd4d5Z%ddd6d1d7d8Z&ddd d:d;Z'd<d= Z(dddddd9d>d?d@dAdddBdCdDdEZ)ddddFdd9dGd@dAdBdddHdIdJZ*dddKdLdMZ+e,j-dd#ddOdPZ.dQdR Z/dSdTdUdVdWZ0dXdY Z1dZdd[d\Z2 fd]d^Z3e4d_d dd`daZ5e5Z6e4dbdcdd Z7e4dedfdg Z8e4dhdidj Z9e4dkdldm Z:e4dndodp Z;e4dqdrds Z<e4dtdudv Z=e4dwdxdy Z>d ddzd{Z?d dd|d}Z@d dd~dZAd#dddZBd#dddZCeDd
d
dZEeDdddZFeDdddZGeDdddZHeddddZI  ZJS )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timedeltaarray)r   timedelta64i  z	list[str]
_other_ops	_bool_opsfreq_object_opsdayssecondsmicrosecondsnanoseconds
_field_ops_datetimelike_opsto_pytimedeltatotal_secondsroundfloorceil_datetimelike_methodszTimedelta | NaTTyper:   c                 C  s   t |ddS )Nnsunitr   )rB   xrF   rF   rG   	_box_func   s    zTimedeltaArray._box_funcznp.dtypec                 C  s   t 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
        )r   rB   rF   rF   rG   dtype   s    zTimedeltaArray.dtypeNFboolcopyc           	      C  sj  t |dd}t|tr&|jdtjd}t|dd }|d k}|tjk	rH|nd }t|t	| r|r`n6|d krp|j
}n&|r|j
rt|}t||j
d\}}|j}t|tjsdt	|j d}t||jd	krtd
|jdkr|t}t|j t|}|dkrd}t||r| }|r,t|}tj| ||d || _|d krf|d k	rft	| | | d S )NTZextract_numpyint64Zna_value_freqFzUnexpected type 'zZ'. 'values' must be a TimedeltaArray, ndarray, or Series or Index containing one of those.)      z.Only 1-dimensional input arrays are supported.i8ZinferzUFrequency inference not allowed in TimedeltaArray.__init__. Use 'pd.array()' instead.rC   rg   )r/   
isinstancer,   to_numpyr   r   getattrr   
no_defaulttyperR   r   dtlvalidate_inferred_freq_ndarraynpndarrayrJ   
ValueErrorndimrg   viewr   _validate_td64_dtyperj   r   __init__rn   _validate_frequency)	rB   rC   rg   rR   rj   inferred_freqexplicit_none_msgrF   rF   rG   r      sJ    






zTimedeltaArray.__init__r9   zBaseOffset | None)rC   rR   r;   c                   sP   |t kst|t|tjs(tt||jt ks6tt j|t d}||_	|S )Nrr   )
r   AssertionErrorrs   r{   r|   rw   rg   super_simple_newrn   )clsrC   rR   rg   rD   	__class__rF   rG   r      s    zTimedeltaArray._simple_newrg   rj   rj   r;   c                C  s>   |rt | t||d d\}}td |d\}}| j||dS )Nrj   rb   FrR   )r   sequence_to_td64nsrx   ry   r   )r   datarg   rj   r   rR   r   rF   rF   rG   _from_sequence   s
    zTimedeltaArray._from_sequencec           
      C  s   |rt | |d k}|tjk	r"|nd }t|\}}t|||d\}}t|||\}}|r`d }| j||d}	|d kr|d k	r| |	| n|rt	|	j
|	_|	S )Nr   r   )r   r   rv   rx   Zmaybe_infer_freqr   ry   r   r   r   r   rn   )
r   r   rg   rj   rR   rb   r   Z
freq_inferr   rD   rF   rF   rG   _from_sequence_not_strict  s    	z(TimedeltaArray._from_sequence_not_strictc           	      C  s   t |}|d kr2tdd |||fD r2tdt||||dkrNtd|d k	r^t|}|d k	rnt|}t |\}}|d k	rt||||}nt	
|j|j|d}|s|dd  }|s|d d }| j|d	|d
S )Nc                 s  s   | ]}|d kV  qd S NrF   .0rd   rF   rF   rG   	<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 specifiedrq   ro   m8[ns]r   )rx   Zvalidate_periodsanyr}   comZcount_not_noner   Zvalidate_endpointsr.   r{   Zlinspacevalueastyper   r   )	r   startendZperiodsrR   closedZleft_closedZright_closedindexrF   rF   rG   _generate_range(  s(    
 zTimedeltaArray._generate_rangeznp.timedelta64)setitemr;   c                 C  s8   t || js|tk	rtd| j||d t|jdS )Nz'value' should be a Timedelta.)r   r`   )rs   _scalar_typer	   r}   _check_compatible_withr{   rO   r   )rB   r   r   rF   rF   rG   _unbox_scalarL  s    zTimedeltaArray._unbox_scalarc                 C  s   t |S r   rc   )rB   r   rF   rF   rG   _scalar_from_stringR  s    z"TimedeltaArray._scalar_from_stringNonec                 C  s   d S r   rF   )rB   otherr   rF   rF   rG   r   U  s    z%TimedeltaArray._check_compatible_withTc                 C  s4   t |}|jdkr"t| j||dS tjj| ||dS )Nmri   )r$   kindr   rz   rx   ZDatetimeLikeArrayMixinr   )rB   rg   rj   rF   rF   rG   r   \  s    
zTimedeltaArray.astypec           	      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 )Nro   i'  TZbox)r~   rangelenr?   minr   )	rB   ir   length	chunksizechunksZstart_iZend_iZ	convertedrF   rF   rG   __iter__h  s    
zTimedeltaArray.__iter__r   )axisrg   outkeepdimsinitialskipna	min_countz
int | NonezNpDtype | Noneint)r   rg   r   r   r   c          	      C  s6   t d||||d tj| j|||d}| ||S )NrF   )rg   r   r   r   )r   r   r   )nvZvalidate_sumr)   Znansumrz   Z_wrap_reduction_result)	rB   r   rg   r   r   r   r   r   rD   rF   rF   rG   sum{  s        zTimedeltaArray.sumro   )r   rg   r   ddofr   r   )r   rg   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 )NrF   )rg   r   r   std)fname)r   r   r   ro   )r   Zvalidate_stat_ddof_funcr)   Znanstdrz   r~   re   Z_from_backing_data)rB   r   rg   r   r   r   r   rD   rF   rF   rG   r     s    
 
 
zTimedeltaArray.std)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._formatterr	   c                   s2   ddl m} || j| t fdd| jD S )Nr   r   c                   s   g | ]} |qS rF   rF   r   	formatterrF   rG   
<listcomp>  s     z7TimedeltaArray._format_native_types.<locals>.<listcomp>)r   r   rz   r{   array)rB   Zna_repZdate_formatkwargsr   rF   r   rG   _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 )rs   r   r   	TypeErrorrw   rJ   rB   r   rF   rF   rG   _add_offset  s    zTimedeltaArray._add_offsetr   r4   )r   r;   c                 C  s2   ddl m} t|j| j}|||jd}||  S )z&
        Add a Period object.
        r   )r4   r   )Zpandas.core.arrays.periodr4   r{   Zbroadcast_toZordinalshaperR   )rB   r   r4   Zi8valsZothrF   rF   rG   _add_period  s    zTimedeltaArray._add_periodc                 C  s(   t |tjr ddlm} ||}||  S )zS
        Add DatetimeArray/Index or ndarray[datetime64] to TimedeltaArray.
        r   r3   )rs   r{   r|   pandas.core.arraysr3   )rB   r   r3   rF   rF   rG   _add_datetime_arraylike  s    z&TimedeltaArray._add_datetime_arrayliker3   c                 C  s   ddl m} |tk	stt|}|tkrD| jdt  }||S | j}t||j	| j
d}| |}|jrxt|jdnt}|||| jdS )Nr   r   zm8[ms])Zarr_mask)tz)rg   rR   )r   r3   r	   r   r   r?   r   Zto_datetime64r*   r   _isnanrA   r   r%   r   rR   )rB   r   r3   rD   rq   rg   rF   rF   rG   _add_datetimelike_scalar  s    
z'TimedeltaArray._add_datetimelike_scalarc              
     sN   zt  ||W S  tk
rH } ztdt| j |W 5 d }~X Y nX d S )Nz+Cannot add/subtract non-tick DateOffset to )r   _addsub_object_arrayAttributeErrorr   rw   rJ   )rB   r   operrr   rF   rG   r     s    z#TimedeltaArray._addsub_object_array__mul__c                   s   t  rBj  }d }jd k	r2t s2j  }t||dS t dsVt  t tkrxt	 j
sxtdt j
r fddttD }t|}t|S j  }t|S )Nr   rg   z$Cannot multiply with unequal lengthsc                   s   g | ]}|  |  qS rF   rF   r   nr   rB   rF   rG   r     s     z*TimedeltaArray.__mul__.<locals>.<listcomp>)r!   rz   rR   r(   rw   hasattrr{   r   r   r#   rg   r}   r    r   )rB   r   rD   rR   rF   r   rG   r     s     






zTimedeltaArray.__mul____truediv__c                   sx  t || jrHt|}|tkr>tj| jtjd}|tj	 |S | j
| S t|r| j
| }d }| jd k	rv| jj| }t| ||dS t|dst|}t|t| krtdnt|jr| j
| S t|jr^|  |   fddttD }t|| j}t|}|dkrF| }t| ||j}n|dkrZ|t}|S | j
| }t| |S d S )	Nrg   r   rg   *Cannot divide vectors with unequal lengthsc                   s   g | ]}|  |  qS rF   rF   r   ZoravZsravrF   rG   r   :  s     z.TimedeltaArray.__truediv__.<locals>.<listcomp>r   Zfloating)rs   _recognized_scalarsr   r	   r{   emptyr   r<   fillnanrz   r   r!   rR   deltarw   r   r   r   r}   r#   rg   r    Zravelr   Zreshapeinfer_dtyper   r   float)rB   r   rD   rR   inferredZflatrF   r   rG   r     sB    













zTimedeltaArray.__truediv____rtruediv__c                   s  t  jrHt   tkr>tjjtjd}|tj	 |S  j
 S t rrtdt j dtj t dst  t tkrtdn`t jr j
 S t jr fddttD }t|S td j dtj d S )	Nr   Cannot divide  by rg   r   c                   s   g | ]} | |  qS rF   rF   r   r   rF   rG   r   n  s     z/TimedeltaArray.__rtruediv__.<locals>.<listcomp>z	 data by )rs   r   r   r	   r{   r   r   r<   r   r   rz   r   r!   r   rw   rJ   r   r   r   r}   r#   rg   r    r   )rB   r   rD   rF   r   rG   r   L  s.    








zTimedeltaArray.__rtruediv____floordiv__c                   s  t  rt jrVt   tkrFtjjtjd}|	tj
 |S  j}|S j  }t|jt d }jd k	rj  }|jdkrjjdkrd }t|d|dS t dst  t tkrtdnt jrBt  j j }j jB }| r>|tj}t||tj
 |S t jr fddttD }t|}tj |d	d
dkrt!|\}}t|S |S t" jst# jr҈j  }t|S t$ dt j%}t&d| dtj% d S )Nr   r   r   r   rg   "Cannot divide with unequal lengthsc                   s   g | ]}|  |  qS rF   rF   r   r   rF   rG   r     s    z/TimedeltaArray.__floordiv__.<locals>.<listcomp>F)r   r   r   r   )'r!   rs   r   r   r	   r{   r   r   r<   r   r   __rfloordiv__rz   r?   putmaskr   r   rR   Znanosrw   r   r   r   r   r}   r#   rg   r   r   r    r   r   r   r   r   r   ru   rJ   r   )rB   r   rD   rR   maskr   rg   rF   r   rG   r   v  sV    








zTimedeltaArray.__floordiv__r   c                   s`  t  rvt jrVt   tkrFtjjtjd}|	tj
 |S  j}|S tdt j dtj t dst  t tkrtdnt jrt   jj }j jB }| r|tj}t||tj
 |S t jr0 fddttD }t|}|S t dt j}td| dtj d S )Nr   r   r   rg   r   c                   s   g | ]} | |  qS rF   rF   r   r   rF   rG   r     s    z0TimedeltaArray.__rfloordiv__.<locals>.<listcomp>)r!   rs   r   r   r	   r{   r   r   r<   r   r   r   rz   r   rw   rJ   r   r   r   r}   r#   rg   r?   r   r   r   r   r    r   ru   )rB   r   rD   r   rg   rF   r   rG   r     s@    





zTimedeltaArray.__rfloordiv____mod__c                 C  s$   t || jrt|}| | | |  S r   rs   r   r   r   rF   rF   rG   r     s    zTimedeltaArray.__mod____rmod__c                 C  s$   t || jrt|}|||  |   S r   r   r   rF   rF   rG   r     s    zTimedeltaArray.__rmod__
__divmod__c                 C  s0   t || jrt|}| | }| ||  }||fS r   r   rB   r   Zres1Zres2rF   rF   rG   r     s
    zTimedeltaArray.__divmod____rdivmod__c                 C  s0   t || jrt|}||  }|||   }||fS r   r   r   rF   rF   rG   r     s
    zTimedeltaArray.__rdivmod__c                 C  s2   | j d k	r"t| | j | j  dS t| | j S Nr   )rR   rw   rz   rf   rF   rF   rG   __neg__  s    
zTimedeltaArray.__neg__c                 C  s   t | | j| jdS r   )rw   rz   rR   rf   rF   rF   rG   __pos__  s    zTimedeltaArray.__pos__c                 C  s   t | t| jS r   )rw   r{   absrz   rf   rF   rF   rG   __abs__  s    zTimedeltaArray.__abs__c                 C  s   | j d| 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
        -------
        seconds : [ndarray, Float64Index, Series]
            When the calling object is a TimedeltaArray, the return type
            is ndarray.  When the calling object is a TimedeltaIndex,
            the return type is a Float64Index. 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()
        Float64Index([0.0, 86400.0, 172800.0, 259200.00000000003, 345600.0],
                     dtype='float64')
        g&.>Nr=   )rA   r?   rf   rF   rF   rG   r[     s    7zTimedeltaArray.total_secondsc                 C  s   t | jS )z
        Return Timedelta Array/Index as object ndarray of datetime.timedelta
        objects.

        Returns
        -------
        timedeltas : ndarray[object]
        )r   r   r?   rf   rF   rF   rG   rZ   W  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.r2   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 )z
        Return a dataframe of the components (days, hours, minutes,
        seconds, milliseconds, microseconds, nanoseconds) of the Timedeltas.

        Returns
        -------
        DataFrame
        r   r1   rT   hoursminutesrU   ZmillisecondsrV   rW   c                   s   t | rtjgt  S | jS r   )r(   r{   r   r   
componentsrd   columnsrF   rG   rH     s    z$TimedeltaArray.components.<locals>.fc                 S  s   | j S r   )r  r  rF   rF   rG   rH     s    c                   s   g | ]} |qS rF   rF   r   )rH   rF   rG   r     s     z-TimedeltaArray.components.<locals>.<listcomp>r  rl   )pandasr2   r@   r   )rB   r2   ZhasnansrD   rF   )r  rH   rG   r  s  s"    
	
zTimedeltaArray.components)N)F)F)T)F)r	   N)KrJ   
__module____qualname__rK   Z_typr   r   r   r{   rO   r   r   r#   Z_is_recognized_dtypeZ_infer_matchesZ__array_priority__rP   __annotations__rQ   rS   rX   rY   r_   re   rL   rg   rn   r   r   rv   r   classmethodr   r   r   r   r   r   r   r   r   r   r   r   rx   Zravel_compatr   r   r   r   r   r   r0   r   __rmul__r   r   r   r   r   r   r   r   r   r   r   r[   rZ   rM   rT   rU   rV   rW   r  __classcell__rF   rF   r   rG   rN   `   s   
  ;  "#   
9
)
C
2


	
	9rN   Fraiserh   ztuple[np.ndarray, Tick | None]r   c                 C  s  d}|dk	rt |}t| dsDt| dkr4t| } tj| dd} n t| trXtdnt	| dd} t| t
r~| jd	td
} n>t| tjtfst| } n"t| tr| jj| jtdj} d}t| tr| j}t| jst| jrt| ||d} d}nt| jrt| |d\} }|o| }nt| jrt| }t |p>d\}}| !tj"}	| |	 }
|rlt#|
|}
|	| |
| !tj" $d} t| |< d}n8t%| jr| jt&krt'| } d}ntd| j dtj| |d} | jdkst(| | |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.
    Nrg   r   Fri   z0Cannot create a DatetimeArray from a MultiIndex.Trk   rl   rm   r  rb   errorsra   r`   timedelta64[ns]dtype ' cannot be converted to timedelta64[ns]r   ))r   r   r{   r~   listr   rs   r'   r   r/   r,   rt   r   r|   r+   Zasarrayr&   
categoriesZtakecodesr	   Z_valuesrN   rR   r    rg   r"   objects_to_td64nsr   ints_to_td64nsr   isnanr   r   rl   r\   r   r#   r   r   r   )r   rj   rb   r  r   	copy_mader   r   pbasefracrF   rF   rG   r     sV    !






r   r`   c                 C  sn   d}|dk	r|nd}| j tjkr0| tj} d}|dkr\d| d}| |} t| } 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
    FNr`   Tztimedelta64[]r  )rg   r{   rl   r   r   r   )r   rb   r  Z	dtype_strrF   rF   rG   r    s    

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  )r{   r   Zobject_r   r   )r   rb   r  rC   rD   rF   rF   rG   r  ,  s    r  r   r:   c                 C  sB   t | } t| tdr$d}t|t| ts>td|  d| S )NrO   zhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.r  r  )r$   r   r{   rg   r}   r   )rg   r   rF   rF   rG   r   P  s    
r   )FNr  )r`   )Nr  )X
__future__r   datetimer   typingr   Znumpyr{   Zpandas._libsr   r   Zpandas._libs.arraysr   Zpandas._libs.tslibsr   r	   r
   r   r   r   r   r   r   Zpandas._libs.tslibs.conversionr   r   Zpandas._libs.tslibs.fieldsr   Zpandas._libs.tslibs.timedeltasr   r   r   Zpandas._typingr   r   Zpandas.compat.numpyr   r   Zpandas.core.dtypes.castr   Zpandas.core.dtypes.commonr   r   r   r   r   r    r!   r"   r#   r$   Zpandas.core.dtypes.dtypesr%   Zpandas.core.dtypes.genericr&   r'   Zpandas.core.dtypes.missingr(   Zpandas.corer)   Zpandas.core.algorithmsr*   r   r+   r,   r-   rx   Zpandas.core.arrays._rangesr.   Zpandas.core.commoncorecommonr   Zpandas.core.constructionr/   Zpandas.core.ops.commonr0   r  r2   r3   r4   rM   ZTimelikeOpsrN   r   r  r  r   rF   rF   rF   rG   <module>   sR   ,0      F     e
(
$