Sindbad~EG File Manager

Current Path : /usr/local/lib/python3.12/site-packages/pandas/core/arrays/__pycache__/
Upload File :
Current File : //usr/local/lib/python3.12/site-packages/pandas/core/arrays/__pycache__/timedeltas.cpython-312.pyc

�

MٜgƓ���ddlmZddlmZddlZddlmZmZddlZ	ddl
mZmZddl
mZmZmZmZmZmZmZmZmZddlmZddlmZmZdd	lmZmZmZm Z m!Z!dd
l"m#Z$ddl%m&Z&ddl'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.dd
l/m0Z0ddl1m2Z2ddl3m4Z4m5Z5ddl6m7Z7ddl8m9Z:ddl;m<Z<ddl=m>cm?Z@ddlAmBZBerddlCmDZDddlEmFZFmGZGmHZHmIZImJZJmKZKddlLmMZMddlNZNdd�ZOGd�de: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�fd�}||_d|�d�|_t|�S)Nc����|j}�dk(rt||j��}nt|�|j��}|jr|j|dd��}|S)N�days��reso�float64)�
fill_value�convert)�asi8r�_cresor�_hasna�_maybe_mask_results)�self�values�result�aliass   ��H/usr/local/lib/python3.12/site-packages/pandas/core/arrays/timedeltas.py�fz_field_accessor.<locals>.fRsa��������F�?�'��T�[�[�A�F�
)���T�[�[�I�F��;�;��-�-��4��.��F��
��
)�returnz
np.ndarray)�__name__�__doc__�property)�namerC�	docstringrEs `  rD�_field_accessorrNQs+���� �A�J��Y�K�r�"�A�I��A�;�rFc���eZdZUdZdZejdd�Zeeje	fZ
d�ZdZe
dUd��ZdZgZd	ed
<gZd	ed<dgZd	ed
<gd�Zd	ed<eezezdgzZd	ed<gd�Zd	ed<dVd�Ze
dWd��ZdZeZed��Zedef							dX�fd�
�Zeddd�dYd��Zedde jBdd�			dYd��Z"e	dZdd�			d[d��Z#d\d �Z$d]d!�Z%d^d"�Z&d_d`d$�Z'dad%�Z(dddddd#d&d'�									dbd(�Z)dddd)dd#d*�									dcd+�Z*d#d,�dd�fd-�Z+dedfd.�Z,ddd/�			dgd0�Z-d1�Z.e/d2�dhd3��Z0e0Z1d4�Z2d5�Z3did6�Z4e/d7�d8��Z5e/d9�d:��Z6e/d;�d<��Z7e/d=�d>��Z8e/d?�d@��Z9e/dA�dB��Z:e/dC�dD��Z;e/dE�dF��Z<djdG�Z=djdH�Z>djdI�Z?dkdJ�Z@dldK�ZAeBj�dL�ZDeEdMdMeD�ZFeBj�dN�ZGeEdOdOeG�ZHeBj�dP�ZIeEdQdQeI�ZJeBj�dR�ZKeEdSdSeK�ZLe
dmdT��ZM�xZNS)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�.�tj|d�S�N�m)r�is_np_dtype��xs rD�<lambda>zTimedeltaArray.<lambda>�s��S�_�_�Q��%<rF)r�timedelta64c��tS�N�r�r@s rD�_scalar_typezTimedeltaArray._scalar_type�s���rFi�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��|jd�}|tjk(rtStj||j
��S)N�i8r7)�viewr	�_valuer�_from_value_and_resor=)r@rX�ys   rD�	_box_funczTimedeltaArray._box_func�s6��
�F�F�4�L����
�
�?��J��-�-�a�d�k�k�B�BrFc�.�|jjS)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 rDrzzTimedeltaArray.dtype�s��"�}�}�"�"�"rFNc�z�t|�}t|j�||jk7rtd��|S)Nz'Values resolution does not match dtype.)�_validate_td64_dtyperz�
ValueError)�clsrArzs   rD�_validate_dtypezTimedeltaArray._validate_dtype�s7��%�U�+���V�\�\�*��F�L�L� ��F�G�G��rFc�4��tj|d�sJ�tj|�rJ�t	|t
j�sJt|���||jk(sJ�|�t	|t�sJ�t�|�-||��}||_|S)NrU)rArz)
rrVr�is_unitless�
isinstance�np�ndarray�typerzr�super�_simple_new�_freq)r~rArbrzrB�	__class__s     �rDr�zTimedeltaArray._simple_new�s�������u�c�*�*�*��%�%�e�,�,�,��&�"�*�*�-�;�t�F�|�;�-�����$�$�$��|�z�$��5�5�5���$�F�%�$�@������
rFF�rz�copyc��|rt|�}t||d��\}}|�t||d��}|j||j|��S)N�r�rhFr��rzrb)r|�sequence_to_td64nsr
r�rz)r~�datarzr�rbs     rD�_from_sequencezTimedeltaArray._from_sequence�sN���(��/�E�'��4�d�C�
��d���&�t�5�u�E�D����t�4�:�:�D��A�ArF)rzr�rbrhc���|rt|�}|dvsJ�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�rzr�rbrh�
inferred_freqrBs        rD�_from_sequence_not_strictz(TimedeltaArray._from_sequence_not_strict�ss���(��/�E��?�*�*�*�0��D�t�L���m���&�t�5�u�E�D�����T�Z�Z�m��L�����t�R�(��
rF�rhc���tj|�}|� td�|||fD��rtd��t	j
||||�dk7rtd��|�t
|�jd�}|�t
|�jd�}|�|dvr
td��d}|�|�|j|d�	�}|�|�|j|d�	�}t|�\}}|�t|||||�
�}	n:tj|j|j|�jd�}	|s|	dd}	|s|	dd
}	|	jd|�d��}
|j|
|
j |��S)Nc3�$K�|]}|du���
y�wr\�)�.0rXs  rD�	<genexpr>z1TimedeltaArray._generate_range.<locals>.<genexpr>s����I�3H�a��T�	�3H�s�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�usrRz+'unit' must be one of 's', 'ms', 'us', 'ns'F)�round_okr�rr����zm8[�]r�)�dtl�validate_periods�anyr}�com�count_not_nonerrorr)r��linspacert�astypersr�rz)r~�start�end�periodsrb�closedrh�left_closed�right_closed�index�
td64valuess           rD�_generate_rangezTimedeltaArray._generate_ranges����&�&�w�/���<�C�I�G�U�C�3H�I�I��P�Q�Q����e�S�'�4�8�A�=��<��
�
���e�$�,�,�T�2�E��?��C�.�(�(��.�C����2�2� �!N�O�O��D����!1��M�M�$��M�7�E��?�t�/��+�+�d�U�+�3�C�$6�v�$>�!��\���*�5�#�w��4�P�E��K�K����c�j�j�'�B�I�I�$�O�E���!�"�I�E���#�2�J�E��Z�Z�#�d�V�1�
�.�
����z��1A�1A���M�MrFc�$�t||j�s|turtd��|j	|�|tur*tj|j|j�S|j|j�jS)Nz'value' should be a Timedelta.)r�r_r	r}�_check_compatible_withr�rZrtrhro�asm8�r@�values  rD�
_unbox_scalarzTimedeltaArray._unbox_scalar?sl���%��!2�!2�3��S�8H��=�>�>��#�#�E�*��C�<��>�>�%�,�,��	�	�:�:��=�=����+�0�0�0rFc��t|�Sr\r]r�s  rD�_scalar_from_stringz"TimedeltaArray._scalar_from_stringHs
�����rFc��yr\r��r@�others  rDr�z%TimedeltaArray._check_compatible_withKs��rFTc��t|�}tj|d�r�||jk(r|r|j	�S|St|�rIt
|j|d��}t|�j||j|j��Std|j�d|�d���tjj|||��S)NrUF�r�r�zCannot convert from z to z1. Supported resolutions are 's', 'ms', 'us', 'ns')r"rrVrzr�rr
ryr�r�rbr}r��DatetimeLikeArrayMixinr�)r@rzr��
res_valuess    rDr�zTimedeltaArray.astypeRs���
�U�#���?�?�5�#�&���
�
�"���9�9�;�&���!�%�(�0�����E�R�
��D�z�-�-��j�&6�&6�T�Y�Y�.���!�*�4�:�:�,�d�5�'�BF�F���
�)�)�0�0��u�4�0�H�HrFc#�4K�|jdkDr!tt|��D]	}||���y|j}t|�}d}||zdz}t|�D]3}||z}t	|dz|z|�}t|||d��}|Ed{����5y7��w)Nr�i'T��box)�ndim�range�lenry�minr)	r@�ir��length�	chunksize�chunks�start_i�end_i�	converteds	         rD�__iter__zTimedeltaArray.__iter__ms������9�9�q�=��3�t�9�%���1�g�
�&��=�=�D���Y�F��I��	�)�Q�.�F��6�]���i�-���Q��U�i�/��8��/��W�U�0C��N�	�$�$�$�	#�%�s�BB�B�Br)�axisrz�out�keepdims�initial�skipna�	min_countc��tjd||||d��tj|j|||��}|j||�S)Nr�)rzr�r�r�)r�r�r�)�nv�validate_sumr%�nansumry�_wrap_reduction_result)	r@r�rzr�r�r�r�r�rBs	         rD�sumzTimedeltaArray.sum�sP��	����%���g�V�	
�����M�M��V�y�
���*�*�4��8�8rFr�)r�rzr��ddofr�r�c���tjd|||d�d��tj|j|||��}|�|j
dk(r|j
|�S|j|�S)Nr�)rzr�r��std)�fname)r�r�r�r�)r��validate_stat_ddof_funcr%�nanstdryr�rw�_from_backing_data)r@r�rzr�r�r�r�rBs        rDr�zTimedeltaArray.std�si��	�"�"��%���B�%�	
����t�}�}�4��T�R���<�4�9�9��>��>�>�&�)�)��&�&�v�.�.rF)r�c���|dk(rZtt|�}||jj�fd|i|��}t	|�j|d|j��S|dk(rtd��t�|�$|fd|i|��S)N�cumsumr�)rbrz�cumprodz$cumprod not supported for Timedelta.)
�getattrr'ryr�r�r�rz�	TypeErrorr��_accumulate)r@rLr��kwargs�oprBr�s      �rDr�zTimedeltaArray._accumulate�s�����8���3�T�:�B���
�
�*�*�,�F�V�F�v�F�F���:�)�)�&�t�4�:�:�)�N�N�
�Y�
��B�C�C��7�&�t�E�F�E�f�E�ErFc�"�ddlm}||d��S)Nr��get_format_timedelta64Tr�)�pandas.io.formats.formatr�)r@�boxedr�s   rD�
_formatterzTimedeltaArray._formatter�s��C�%�d��5�5rF)�na_rep�date_formatc�n�ddlm}|||�}tj|dd�|j�S)Nrr�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�-�d�m�m�<�<rFc��t|t�rJ�tdt|�j�dt|�j����)Nzcannot add the type z to a )r�rr�r�rIr�s  rD�_add_offsetzTimedeltaArray._add_offset�sE���e�T�*�*�*��"�4��;�#7�#7�"8��t�D�z�?R�?R�>S�T�
�	
rF�__mul__c�$�t|�r�|j|z}|jjdk7r!t	dt|�j����d}|j�+t|�s |j|z}|jdk(rd}t|�j||j|��St|d�stj|�}t|�t|�k7r+tj |jd�st#d��t%|j�rq|j}t't|��D�cgc]
}||||z��}}tj|�}t|�j||j��S|j|z}|jjdk7r!t	dt|�j����t|�j||j��Scc}w)NrUzCannot multiply with rr�rzz$Cannot multiply with unequal lengths�rz)r ryrz�kindr�r�rIrbr$�nr��hasattrr��arrayr�rrVr}rr�)r@r�rBrb�arrrs      rDr�zTimedeltaArray.__mul__�s����U���]�]�U�*�F��|�|� � �C�'� �"7��U��8L�8L�7M� N�O�O��D��y�y�$�T�%�[��y�y�5�(���6�6�Q�;��D���:�)�)�&����4�)�P�P��u�g�&��H�H�U�O�E��u�:��T��"�3�?�?�5�;�;��+L��C�D�D��5�;�;�'��-�-�C�16�s�4�y�1A�B�1A�A�c�!�f�u�Q�x�'�1A�F�B��X�X�f�%�F���:�)�)�&����)�E�E�����&���<�<����#��3�D��K�4H�4H�3I�J�K�K��D�z�%�%�f�F�L�L�%�A�A��Cs�H
c���t||j�r�t|�}td|�turPtj|jt
j��}|jt
j�|S||j|�S|tjtjfvr7tdt!|�j"�dt!|�j"����||j|�}d}|j$�9|j$|z}|j&dk(r|j$j&dk7rd}t!|�j)||j*|��S)zv
        Shared logic for __truediv__, __rtruediv__, __floordiv__, __rfloordiv__
        with scalar 'other'.
        �Timedelta | NaTTyperzCannot divide z by Nrr�)r��_recognized_scalarsrrr	r��empty�shaper9�fill�nanryr&�rtruediv�	rfloordivr�r�rIrb�nanosr�rz)r@r�r��resrBrbs      rD�_scalar_divlike_opz!TimedeltaArray._scalar_divlike_op�s0��
�e�T�5�5�6��e�$�E��)�5�1�S�8��h�h�t�z�z����<�������� ��
��d�m�m�U�+�+��i�(�(�)�*=�*=�>�>��$�T�%�[�%9�%9�$:�$�t�D�z�?R�?R�>S�T�����
�
�u�-�F��D��y�y�$��y�y�5�(���:�:��?�t�y�y���!�';� �D���:�)�)�&����4�)�P�PrFc��t|d�stj|�}t|�t|�k7rt	d��|S)Nrzz*Cannot divide vectors with unequal lengths)rr�rr�r}r�s  rD�_cast_divlike_opzTimedeltaArray._cast_divlike_op's:���u�g�&��H�H�U�O�E��u�:��T��"��I�J�J��rFc�Z�||jtj|��}t|j�st|j�rH|tjtjfvr&t|�j||j��S|tjtjfvrp|j�t|�z}|j�rD|jtj �}tj"||tj$�|S)z�
        Shared logic for __truediv__, __floordiv__, and their reversed versions
        with timedelta64-dtype ndarray other.
        r)ryr��asarrayrrzr�operator�truediv�floordivr�r�r&rr$r�r�r9�putmaskr)r@r�r�rB�masks     rD�_vector_divlike_opz!TimedeltaArray._vector_divlike_op0s����D�M�M�2�:�:�e�#4�5���U�[�[�)�^�E�K�K�-H�b�������U
�O
���:�)�)�&����)�E�E�
�(�#�#�Y�%8�%8�9�9��9�9�;��e��,�D��x�x�z����r�z�z�2���
�
�6�4����0��
rF�__truediv__c��tj}t|�r|j||�S|j	|�}tj|jd�s*t|j�st|j�r|j||�St|j�r�tj|�}|jdkDrYt||�D��cgc]
\}}||z��}}}|D�cgc]}|j!dd���}}tj"|d��}|St%|j&|�}|St(Scc}}wcc}w�NrUr�r�r)r�)rrr rrrrVrzrrrrr�rr��zip�reshape�concatenaterry�NotImplemented�	r@r�r��left�right�res_colsrX�	res_cols2rBs	         rDrzTimedeltaArray.__truediv__Fs���
�
���U���*�*�5�"�5�5��%�%�e�,���O�O�E�K�K��-�����,��e�k�k�*��*�*�5�"�5�5��5�;�;�'��J�J�u�%�E��y�y�1�}�<?��e�<L�M�<L�[�T�5�D�5�L�<L��M�7?�@�x�!�Q�Y�Y�q�"�-�x�	�@����	��:���M�.�d�m�m�U�C���M�"�!��N��@s�#E�9E�__rtruediv__c��tj}t|�r|j||�S|j	|�}tj|jd�r|j||�St|j�r?tt|��D�cgc]
}||||z��}}tj|�StScc}wrT)r&r
r rrrrVrzrrr�r�r�rr")r@r�r�r�result_lists     rDr(zTimedeltaArray.__rtruediv__cs����
�
���U���*�*�5�"�5�5��%�%�e�,���?�?�5�;�;��,��*�*�5�"�5�5�
�U�[�[�
)�8=�S��Y�7G�H�7G�!�5��8�d�1�g�-�7G�K�H��8�8�K�(�(�"�!��	Is�C�__floordiv__c���tj}t|�r|j||�S|j	|�}tj|jd�s*t|j�st|j�r|j||�St|j�r�tj|�}|jdkDrXt||�D��cgc]
\}}||z��}}}|D�cgc]}|j!dd���}}tj"|d��}nt%|j&|�}|jt(k(sJ�|St*Scc}}wcc}wr)rrr rrrrVrzrrrrr�rr�rr r!rry�objectr"r#s	         rDr+zTimedeltaArray.__floordiv__xs&��
�
�
���U���*�*�5�"�5�5��%�%�e�,���O�O�E�K�K��-�����,��e�k�k�*��*�*�5�"�5�5�
�U�[�[�
)��J�J�u�%�E��y�y�1�}�=@��u�=M�N�=M�k�d�E�D�E�M�=M��N�7?�@�x�!�Q�Y�Y�q�"�-�x�	�@����	��:��.�t�}�}�e�D���<�<�6�)�)�)��M�"�!��O��@s�#E�9E%�
__rfloordiv__c��tj}t|�r|j||�S|j	|�}tj|jd�r|j||�St|j�rAtt|��D�cgc]
}||||z��}}tj|�}|StScc}wrT)r&rr rrrrVrzrrr�r�r�rr")r@r�r�rr*rBs      rDr.zTimedeltaArray.__rfloordiv__�s���
�
 �
 ���U���*�*�5�"�5�5��%�%�e�,���?�?�5�;�;��,��*�*�5�"�5�5�
�U�[�[�
)�8=�c�$�i�8H�I�8H�1�5��8�t�A�w�.�8H�K�I��X�X�k�*�F��M�"�!��Js�C
�__mod__c�Z�t||j�rt|�}|||z|zz
Sr\�r�rrr�s  rDr0zTimedeltaArray.__mod__�s2���e�T�5�5�6��e�$�E��t�u�}��-�-�-rF�__rmod__c�Z�t||j�rt|�}|||z|zz
Sr\r2r�s  rDr3zTimedeltaArray.__rmod__�s2���e�T�5�5�6��e�$�E����
��-�-�-rF�
__divmod__c�f�t||j�rt|�}||z}|||zz
}||fSr\r2�r@r��res1�res2s    rDr5zTimedeltaArray.__divmod__�s?���e�T�5�5�6��e�$�E��u�}���d�U�l�"���T�z�rF�__rdivmod__c�f�t||j�rt|�}||z}|||zz
}||fSr\r2r7s    rDr:zTimedeltaArray.__rdivmod__�s?���e�T�5�5�6��e�$�E���}���t�d�{�"���T�z�rFc��d}|j�
|j}t|�j|j|j|��S�Nr�)rbr�r�ryrz)r@rbs  rD�__neg__zTimedeltaArray.__neg__�sB�����9�9� ��I�I�:�D��D�z�%�%�t�}�}�n�D�J�J�T�%�R�RrFc��t|�j|jj�|j|j
��Sr=)r�r�ryr�rzrbr^s rD�__pos__zTimedeltaArray.__pos__�s:���D�z�%�%��M�M��� ��
�
����&�
�	
rFc��t|�jtj|j�|j
��S)Nr)r�r�r��absryrzr^s rD�__abs__zTimedeltaArray.__abs__�s-���D�z�%�%�b�f�f�T�]�]�&;�4�:�:�%�N�NrFc�l�t|j�}|j|j|zd��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:)rr=r?r<)r@�ppss  rDrkzTimedeltaArray.total_seconds�s1��l!����-���'�'��	�	�C��D�'�I�IrFc�,�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)
        )rryr^s rDrjzTimedeltaArray.to_pytimedeltas��$#�4�=�=�1�1rFaCNumber 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')r6a�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')rda�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')rea�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')rfc���ddlm}gd��|j}|r�fd�}nd�}||D�cgc]
}||���c}���}|s|jd�}|Scc}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
        rr2)r6�hours�minutesrd�millisecondsrerfc�l��t|�rtjgt��zS|jSr\)r$r�rr��
components)rX�columnss �rDrEz$TimedeltaArray.components.<locals>.f�s)�����7��F�F�8�c�'�l�2�2��|�|�#rFc��|jSr\)rLrWs rDrEz$TimedeltaArray.components.<locals>.f�s���|�|�#rF)rM�int64)�pandasr3r>r�)r@r3�hasnansrErXrBrMs      @rDrLzTimedeltaArray.components�sc���,	%�
���+�+���
$�
$��$�/�$�Q�A�a�D�$�/��A����]�]�7�+�F��
��0s�A)rHztype[Timedelta])rX�np.timedelta64rHr)rH�np.dtype[np.timedelta64])rAznpt.NDArray[np.timedelta64]rbzTick | NonerzrSrHr0)r��boolrHr0r\)rhz
str | NonerHr0)rHrR)rHr)rH�None)T)r�rT)rHr+)
r��AxisInt | Nonerz�NpDtype | Noner�rTr�rTr��int)
r�rVrzrWr�rXr�rTr�rT)rL�strr�rT)F)r�rT)r�zstr | floatrH�npt.NDArray[np.object_])rHr0)rHznp.ndarray | Self)rHrP)rHznpt.NDArray[np.float64])rHrZ)rHr3)OrI�
__module__�__qualname__rJ�_typr�rZ�_internal_fill_valuerrr�_is_recognized_dtype�_infer_matchesrKr_�__array_priority__r`�__annotations__rarcrgrirprwrzr�r�_default_dtype�classmethodrr�r�r�
no_defaultr�r�r�r�r�r�r�r�r�r�r�r�r�r*r��__rmul__rrrrr(r+r.r0r3r5r:r>r@rCrkrj�textwrap�dedent�days_docstringrNr6�seconds_docstringrd�microseconds_docstringre�nanoseconds_docstringrfrL�
__classcell__)r�s@rDrPrPgso���#�J�D�)�2�>�>�%��6��$�b�n�n�d�;��<��1�N�
�������J�	���I�y��$�X�K��%�N�J�	�N�#-��#;�i�#G�6�(�#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�7J�r2�(%�X�_�_�	)��N�8�6�6�>�:�D�'����	'���8�����G�-�X�_�_�	'���:#�����L�,�H�O�O�	'���:"�����K��0��0rFrPc�"�|dvsJ�d}|�t|�}tj||d��\}}t|t�r|j
}|jtk(st|j�rt|||��}d}�n+t|j�rt||��\}}|xr|}n�t|j�rut|jt�r|j}|j}nt!j"|�}t%||xsd�}t&||<|j)d	�}d}ntt+j,|jd
�r;t/|j�s?t1|j�}t3||d��}d}nt5d|j�d
���|st!j6|�}nt!j8||��}|jj:d
k(sJ�|jdk7sJ�||fS)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�rRzm8[ns]rUr�zdtype z' cannot be converted to timedelta64[ns]r��m8)rr��!ensure_arraylike_for_datetimeliker�rPrbrzr-r!�_objects_to_td64nsr�_ints_to_td64nsrr#�_mask�_datar��isnanrrrsrrVrrr
r�rrr)r�r�rhrqr��	copy_mader�	new_dtypes        rDr�r��s���H��&�&�&��M���#�D�)���6�6��d�-��J�D�$��$��'��	�	�
��z�z�V���t�z�z�:�!�$�T�&�A����	�$�*�*�	%�)�$�T�:���i��%�I�
��	��
�
�	#��d�j�j�.�1��:�:�D��:�:�D��8�8�D�>�D�(��t�|�t�<����T�
��y�y��"����	������S�	)�!�$�*�*�-�+�D�J�J�7�I�&�t�9�5�I�D��D��&�����,S�T�U�U���z�z�$����x�x��4�(���:�:�?�?�c�!�!�!��:�:��������rFc��d}|�|nd}|jtjk7r!|jtj�}d}|dk7r.d|�d�}|j	|�}t|t��}d}||fS|j	d�}||fS)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
    FrRTztimedelta64[r�r�timedelta64[ns])rzr�rOr�rsr
r)r�rhry�	dtype_strs    rDruruFs��� �I��#�4��D��z�z�R�X�X���{�{�2�8�8�$���	��t�|�"�4�&��*�	��y�y��#��"�4�|�<���	�
��?���y�y�*�+����?�rFc��tj|tj��}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.
    rrpr|)r�r�object_rrs)r�rhrqrArBs     rDrtrtns6��<�Z�Z��B�J�J�
/�F�
!�&�t�F�
C�F��;�;�(�)�)rFc���t|�}|tjd�k(r
d}t|��t	j
|d�std|�d���t
|�std��|S)NrrzhPassing in 'timedelta' dtype with no precision is not allowed. Please pass in 'timedelta64[ns]' instead.rUzdtype 'z,' is invalid, should be np.timedelta64 dtypez;Supported timedelta64 resolutions are 's', 'ms', 'us', 'ns')r"r�rzr}rrVr)rz�msgs  rDr|r|�sn�����E��������
8�	���o���?�?�5�#�&��7�5�'�)U�V�W�W�
��
&��V�W�W��LrF)rLrYrCrYrMrY)FN�raise)r�rTrqr-rHztuple[np.ndarray, Tick | None])rR)rhrY)Nr�)rqr-)rHr.)V�
__future__r�datetimerr�typingrr�numpyr��pandas._libsrr�pandas._libs.tslibsr	r
rrr
rrrr�pandas._libs.tslibs.conversionr�pandas._libs.tslibs.fieldsrr�pandas._libs.tslibs.timedeltasrrrrr�pandas.compat.numpyrr��pandas.util._validatorsr�pandas.core.dtypes.commonrrrrr 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/r0r1rPr3rgrN�TimelikeOpsrPr�rurtr|r�rFrD�<module>r�s���"����
��
�
�
�E����/�6����5�+��?�2�=� � �;��(���!���,x
�S�_�_�x
�B�	
�#*�	]�
�]�
!�	]�
$�]�@%�P!*�HrF

Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists