Sindbad~EG File Manager

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

�

Mٜg�����ddlmZddlZddlZddlZddlZddlmZmZm	Z	m
Z
mZddlZddl
ZddlmZddlmZmZmZmZddlmZmZmZddlmZddlmZdd	lmZm Z dd
l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)ddl*m+Z+ddl,m-Z-dd
l.m/Z0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl:m;Z;ddl<m=Z=m>Z>ddl?m@Z@ddlAmBZBddlCmDcmEZFddlGmHZHmIZImJZJddlKmLZLddlMmNZNddlOmPZPe�sddlQZRddlSmTZUddl*mVZVeUj�eUj�eUj�eUj�eUj�eUj�d�Z]eUj�d�eUj�d�eUj�d�d�ZaeUj�d�eUj�d �eUj�d!�d�Ze						dFd"�Zf						dGd#�Zgid$eUj��d%d&��d'eUj��d(d)��d*eUj��d+d,��d-d.��d/d0��d1d2��d3d4��d5ek�d6ek�d7ek�d8ek�d9eUj��d:d;��Zmer>dd<lnmoZodd=lpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZm�Z�m�Z�dd>l�m�Z�dd?l�m�Z�dd@l�m�Z�dA�Z�				dHdB�Z�GdC�dDe7e>e9eL�Z�				dIdE�Z�y)J�)�annotationsN)�
TYPE_CHECKING�Any�Callable�Literal�cast)�lib)�NaT�	Timedelta�	Timestamp�	timezones)�pa_version_under10p1�pa_version_under11p0�pa_version_under13p0)�doc)�validate_fillna_kwargs)�can_hold_element�infer_dtype_from_scalar)�CategoricalDtype�
is_array_like�
is_bool_dtype�is_float_dtype�
is_integer�is_list_like�is_numeric_dtype�	is_scalar)�DatetimeTZDtype)�isna)�
algorithms�missing�ops�	roperator)�	map_array)�OpsMixin)�ArrowStringArrayMixin)�to_numpy_dtype_inference)�ExtensionArray�ExtensionArraySupportsAnyAll)�BaseMaskedArray)�StringDtype)�check_array_indexer�unpack_tuple_and_ellipses�validate_indices)�BaseStringArrayMethods)�_arrow_dtype_mapping)�	to_offset)�
ArrowDtype)�eq�ne�lt�gt�le�gec�.�tj||�S�N)�pc�
and_kleene��x�ys  �I/usr/local/lib/python3.12/site-packages/pandas/core/arrays/arrow/array.py�<lambda>r@^s��b�m�m�A�q�1�c�.�tj||�Sr9)r:�	or_kleener<s  r?r@r@`s��R�\�\�!�Q�/rAc�.�tj||�Sr9)r:�xorr<s  r?r@r@bs��R�V�V�A�q�\rA)�and_�rand_�or_�ror_rE�rxorc�.�tj||�Sr9)r:�bit_wise_andr<s  r?r@r@gs��b�o�o�a��3rAc�.�tj||�Sr9)r:�bit_wise_orr<s  r?r@r@i���R�^�^�A�q�1rAc�.�tj||�Sr9)r:�bit_wise_xorr<s  r?r@r@ks��R�_�_�Q��2rAc�V�tjj|j�r}tjj|j�rTt	j
|tj�d��t	j
|tj�d��fS||fS)NF)�safe)�pa�typesr�typer:r�float64)�arrow_array�	pa_objects  r?�cast_for_truedivrZns|��
�8�8���{�/�/�0�R�X�X�5H�5H��N�N�6
�
�7�7�;��
�
��5�A�2�7�7��2�:�:�<�e�D��
��I�%�%rAc
�d�tjj|j��rZtjj|j��r0t	j
||�}tjj
|j�r�t	jt	j||�|�}t	jt	j||�tjd|j���}t	jt	j||�t	j|tjd|j���|�}n|}|j|j�}|St	j ||�}t	j"|�}|S)Nr�rV�)rTrUrrVr:�divide_checked�is_signed_integer�	not_equal�multiply�lessrQ�scalar�if_elserF�subtractr�divide�floor)�left�right�divided�
has_remainder�has_one_negative_operand�results      r?�floordiv_compatrn~s*���8�8���t�y�y�)�b�h�h�.A�.A�%�*�*�.M��'�'��e�4�G��x�x�)�)�'�,�,�7� "���R�[�[��%�-H�$� O�
�+-�7�7��O�O�D�%�0��I�I�a�g�l�l�3�,�(�����G�G�%�0��
�K�K�����1�7�<�<�)H�I����!���[�[����+�F��
��i�i��e�,�G��X�X�g�&�F��
rA�add�raddc�.�tj||�Sr9)r:�add_checkedr<s  r?r@r@�rOrA�sub�rsubc�.�tj||�Sr9)r:�subtract_checkedr<s  r?r@r@����R�0�0��A�6rA�mul�rmulc�.�tj||�Sr9)r:�multiply_checkedr<s  r?r@r@�rwrA�truedivc�:�tjt||��Sr9�r:rfrZr<s  r?r@r@�s���	�	�+;�A�q�+A� BrA�rtruedivc�:�tjt||��Sr9r~r<s  r?r@r@�s�����,<�Q��,B�!CrA�floordivc��t||�Sr9�rnr<s  r?r@r@�s����A�!6rA�	rfloordivc��t||�Sr9r�r<s  r?r@r@�s��/�!�Q�"7rA�mod�rmod�divmod�rdivmod�pow�rpowc�.�tj||�Sr9)r:�
power_checkedr<s  r?r@r@�s��R�-�-�a��3rA)�Sequence)�	ArrayLike�AxisInt�Dtype�
FillnaOptions�InterpolateOptions�Iterator�NpDtype�NumpySorter�NumpyValueArrayLike�PositionalIndexer�Scalar�Self�SortKind�TakeIndexer�
TimeAmbiguous�TimeNonexistent�npt)�Series)�
DatetimeArray��TimedeltaArrayc��tr2t|�jdd�ddd}|dvrt|��|S|jS)N�[r]���)�s�ms�us�ns)r�str�split�
ValueError�unit)�pa_dtyper�s  r?�get_unit_from_pa_dtyper��sJ����8�}�"�"�3��*�2�.�s��3���.�.��X�&�&����=�=�rAc�J�t|t�r|jSt|tj�r|St|t
�r*tj|j|j�S|r	tj|�Sy#tj$rYywxYw)z3
    Convert dtype to a pyarrow type instance.
    N)�
isinstancer1�
pyarrow_dtyperT�DataTyper�	timestampr��tz�from_numpy_dtype�ArrowNotImplementedError��dtypes r?�to_pyarrow_typer��s����%��$��"�"�"�	�E�2�;�;�	'���	�E�?�	+��|�|�E�J�J����1�1�	�	��&�&�u�-�-����*�*�	���	�s�6B�B"�!B"c�
��eZdZUdZded<ded<d�d�Zeddd	�d�d
��Zeddd	�			d�d��Ze	d�			d�d��Z	ed�d�d
��Z
e	d�					d�d��Zd�d�Zd�d�Z
d�d�Z	d�					d�d�Zd�d�Zd�d�Zd�d�Zd�d�Zd�Zd�d�Zd�Zd�Zd�Zd�Zd�d�Zed�d��Zed�d��Zd�d �Zd��fd!�Zed�d"��Z d�d#�Z!d$d%�d�d&�Z"d$d%�d�d'�Z#d$d(d)d*�							d�d+�Z$dňfd,�Z%d�d�d-�Z&d�d�d.�Z'd�d/�Z(d�d0�Z)ddd$d1�									dȈfd2�Z*e+e,jZ�				d�									dʈfd3�
�Z-d�d4�Z.d�d5�Z/e+e,j`�	d�			d�d6��Z0d7�Z1d�d�d9�Z2e+e,jf�		d�							d�d:��Z3		d�							d�d;�Z4d<�Z5d�d=�Z6d�d>�Z7dֈfd?�Z8e+e,jr�dde:jvf							d�d@��Z9d��fdA�	Z<e+e,jz�	d�			d�dC��Z=d�dD�Z>d�d�dE�Z?ed�dF��Z@d$d%�					dۈfdG�ZAd$d%�d܈fdH�ZBd$ddI�					d�dJ�ZCd$ddI�					d�dK�ZD�fdL�ZEd�dM�ZFd8dNdBd$ddO�									dވfdP�ZGd8dNdBd$ddO�									d�dQ�ZHd�dR�ZId�d�dS�ZJdT�ZK								d�dU�ZLe						d�dV��ZMe						d�dW��ZNdX�ZO										d�fdY�ZPd�dZ�ZQd�d�d[�ZR	d�					d�d\�ZSd�d�d]�ZTd�d�d^�ZU				d�											d�d_�ZVd�d`�ZW	d�							d�da�ZX	d�					d�db�ZYd�d�dc�ZZd�dd�Z[d�de�Z\d�df�Z]	d�					d�dg�Z^dh�Z_di�Z`dj�Zadk�Zbdl�Zcdm�Zddn�Zedo�Zfdp�Zgdq�Zhdr�Zids�Zjd�dt�Zkd�du�Zld�dv�Zmd�dw�Zndx�Zod�d�dy�Zpd�d�dz�Zqd�d�d{�Zrd�d�d|�Zsd�d�d}�Ztd�d�d~�Zud�d�Zvd�d�d��Zw				d�							d�d��Zx�d�dd��Zy�dd��Zz�dd��Z{ed���Z|ed���Z}ed���Z~ed���Zed���Z�ed���Z�ed���Z�d��Z�d��Z��dd��Z�ed���Z�ed���Z�ed���Z�e�Z�e�Z�ed���Z�e�Z�ed���Z�d��Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�e�Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�ed���Z�d��Z��dd��Z�		�d					�dd��Z�		�d			�dd��Z�		�d			�dd��Z�		�d			�dd��Z�d��d	d��Z�d��d	d��Z�d��Z�		�d			�dd��Z�d��Z��xZ�S(
�ArrowExtensionArrayaW
    Pandas ExtensionArray backed by a PyArrow ChunkedArray.

    .. warning::

       ArrowExtensionArray is considered experimental. The implementation and
       parts of the API may change without warning.

    Parameters
    ----------
    values : pyarrow.Array or pyarrow.ChunkedArray

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

    Methods
    -------
    None

    Returns
    -------
    ArrowExtensionArray

    Notes
    -----
    Most methods are implemented using `pyarrow compute functions. <https://arrow.apache.org/docs/python/api/compute.html>`__
    Some methods may either raise an exception or raise a ``PerformanceWarning`` if an
    associated compute function is not available based on the installed version of PyArrow.

    Please install the latest version of PyArrow to enable the best functionality and avoid
    potential bugs in prior versions of PyArrow.

    Examples
    --------
    Create an ArrowExtensionArray with :func:`pandas.array`:

    >>> pd.array([1, 1, None], dtype="int64[pyarrow]")
    <ArrowExtensionArray>
    [1, 1, <NA>]
    Length: 3, dtype: int64[pyarrow]
    �pa.ChunkedArray�	_pa_arrayr1�_dtypec�R�tr
d}t|��t|tj�rtj
|g�|_n:t|tj�r||_ntdt|��d���t|jj�|_y)NzCpyarrow>=10.0.1 is required for PyArrow backed ArrowExtensionArray.zUnsupported type 'z' for ArrowExtensionArray)r�ImportErrorr�rT�Array�
chunked_arrayr��ChunkedArrayr�rVr1r�)�self�values�msgs   r?�__init__zArrowExtensionArray.__init__!s����W�C��c�"�"��f�b�h�h�'��-�-�v�h�7�D�N�
�����
0�#�D�N��$�T�&�\�N�2K�L��
�!����!4�!4�5��rANF�r��copyc�T�t|�}|j|||��}||�}|S)zL
        Construct a new ExtensionArray from a sequence of scalars.
        )�pa_typer�)r��
_box_pa_array)�cls�scalarsr�r�r��pa_array�arrs       r?�_from_sequencez"ArrowExtensionArray._from_sequence/s3��
"�%�(���$�$�W�g�D�$�I���(�m���
rAc��t|�}|�]tjj|�s>tjj	|�stjj|�r|}�n�tjj
|�rddlm}||d��}�n�tjj|�rddlm}||d��j}�nytjj|�r�ddlm
}||d��}|jdk7�r:t|�}t!|tj"tj$f�s*tj&|tj(�d�	�}t+j,|d|�}	|j/tj0��}�n�tjj5|�rdd
lm}	|	|d��}�nmtjj;|�r�t!|tj"tj$f�r|}n*tj&|tj(�d�	�}t+j,t+j<|d�d
|�}t+j,t+j<|d�d|�}|j/tj>��}n}tjjA|�s>tjjC|�stjjE|�rddl#m$}
|
|d��}ntKd|�d���|jM|||��S#tj2$rY�)wxYw)zL
        Construct a new ExtensionArray from a sequence of strings.
        Nr)�to_datetime�raise)�errors��to_timedeltar�T�rV�from_pandas)�to_time�coercez1.0�1z0.0�0)�
to_numericzConverting strings to z is not implemented.r�)'r�rTrU�	is_binary�	is_string�is_large_string�is_timestamp�pandas.core.tools.datetimesr��is_date�date�is_duration�pandas.core.tools.timedeltasr�r�rr�r�r��array�stringr:rdr�int64�ArrowInvalid�is_time�pandas.core.tools.timesr��
is_boolean�equal�bool_r�is_floating�
is_decimal�pandas.core.tools.numericr��NotImplementedErrorr�)r��stringsr�r�r�r�r�r��maskr�r�s           r?�_from_sequence_of_stringsz-ArrowExtensionArray._from_sequence_of_strings9sw��"�%�(���O��x�x�!�!�'�*��x�x�!�!�'�*��x�x�'�'��0��G�
�X�X�
"�
"�7�
+�?�!�'�'�:�G�
�X�X�
�
�g�
&�?�!�'�'�:�?�?�G�
�X�X�
!�
!�'�
*�A�"�7�7�;�G��|�|�t�#��G�}��!�'�B�H�H�b�o�o�+F�G� �h�h�w�R�Y�Y�[�d�S�G��*�*�T�4��9���%�l�l�2�8�8�:�6�G��X�X�
�
�g�
&�7��g�h�7�G�
�X�X�
 �
 ��
)��'�B�H�H�b�o�o�#>�?�!���(�(�7�����$�O���j�j����'�5�!9�3��H�G��j�j����'�5�!9�3��H�G��l�l�2�8�8�:�.�G��H�H����(��x�x�#�#�G�,��x�x�"�"�7�+�<� ���9�G�%�(��	�1E�F��
��!�!�'��t�!�D�D��C������s�#M(�(M>�=M>c��t|tj�st|�s|j	||�S|j||�S)z�
        Box value into a pyarrow Array, ChunkedArray or Scalar.

        Parameters
        ----------
        value : any
        pa_type : pa.DataType | None

        Returns
        -------
        pa.Array or pa.ChunkedArray or pa.Scalar
        )r�rTr�r�_box_pa_scalarr�)r��valuer�s   r?�_box_pazArrowExtensionArray._box_pa�s?�� �e�R�Y�Y�'�|�E�/B��%�%�e�W�5�5�� � ���0�0rAc���t|tj�r|}�n-t|�rtjd|��}�n	t|t
�rc|� tj|j�}n4|j|jk7r|j|j�}|j}n~t|t�rn|�,tj|j|j��}n4|j|jk7r|j|j�}|j}tj||d��}|� |j|k7r|j|�}|S)z�
        Box value into a pyarrow Scalar.

        Parameters
        ----------
        value : any
        pa_type : pa.DataType | None

        Returns
        -------
        pa.Scalar
        Nr\)r�Tr�)r�rTr�rrcr�durationr��as_unit�_valuerr�r�rVr)r�r�r��	pa_scalars    r?r�z"ArrowExtensionArray._box_pa_scalar�s���e�R�Y�Y�'��I�
�%�[��	�	�$�W�5�I��%��+��?� �k�k�%�*�*�5�G��Z�Z�7�<�<�/�!�M�M�'�,�,�7�E������E�9�-��?� �l�l�5�:�:�%�(�(�C�G��Z�Z�7�<�<�/�!�M�M�'�,�,�7�E������	�	�%�g�4�H�I���9�>�>�W�#<�!���w�/�I��rAc��t||�r|j}�nkt|tjtjf�r|}�n=t|t
�r$|r|j
�}|j�}�n	t|tj�rQ|�Otjj|�stjj|�r|j�}n|rt|�r|j
�}|��tjj|�rut|tj�r|j j"dvrCddlm}|||j(��j+|j(�}|j-�}	tj.||d��}|�_tjj|j4�r6ddlm}||�}|j-�}tj.||d��}tjj|j4�rH|j6dkDr9||�}|j9|j j:�}|j}|�T|j4|k7rEtjj=|�r|j?�}|S	|jA|�}|S|S#tj0tj2f$rtj.|d��}Y��gwxYw#tj0tj2tjBf$rstjjE|j4�s)tjj|j4�r|jG||��jcYS�wxYw)	z�
        Box value into a pyarrow Array or ChunkedArray.

        Parameters
        ----------
        value : Sequence
        pa_type : pa.DataType | None

        Returns
        -------
        pa.Array or pa.ChunkedArray
        �mirr��r�Tr��r�r�)$r�r�rTr�r�r)r��__arrow_array__�np�ndarrayrU�is_large_binaryr��tolistrr�r��kindr�r�r�r�to_numpyr�r��ArrowTypeErrorrV�
null_count�fillna�na_value�
is_dictionary�dictionary_encoderr�r�r�)r�r�r�r�r�r�r�s       r?r�z!ArrowExtensionArray._box_pa_array�s��� �e�S�!����H�
�����"�/�/�:�
;��H�
���
/���
�
����,�,�.�H��5�"�*�*�-��'��H�H�,�,�W�5��x�x�/�/��8�������-��.��
�
����#��H�H�(�(��1�#�E�2�:�:�6�%�+�+�:J�:J�RV�:V�F�$�U����>�F�F�w�|�|�T�����(��
=��8�8�E��T�J��
��2�8�8�#7�#7��
�
�#F�E�$�U�+�����(���8�8�E��T�J���x�x�#�#�H�M�M�2�x�7J�7J�Q�7N��(�m���j�j����!3�!3�4���=�=����8�=�=�G�#;��x�x�%�%�g�.�#�5�5�7��(��%�'�}�}�W�5�H�"��x���U�O�O�R�%6�%6�7�
=��8�8�E�t�<��
=��6�O�O��%�%��/�/���
�x�x�)�)�(�-�-�8�B�H�H�<T�<T� �
�
�=�
 #�<�<�!�� =� �#�)�$���s%�K�	L�:L�L�B!O�Oc�H�t||�}t|tj��rt	|�s�|j
jdk(r-|j
jdvrtj�}n|j
j}t|�tjg|���S|jjdvr|j|�S|jjdk(r*t|�|j j#|��St%d��t|t&�rt)|�}|t*urt-d�}t/|�rt1|�st%d��t|t,�r{|j2|j4k(rna|j4�U|j4t	|�kr<|j6�0|j6d	kr!t-|j2d|j6�}|j |}t|tj8�rt|�|�S|j j}|j;�}|�|j
j<Stj>jA|�r3|jBd
k7r$tE|�jG|jB�Stj>jI|�r3|jBd
k7r$tK|�jG|jB�S|S)a8Select a subset of self.

        Parameters
        ----------
        item : int, slice, or ndarray
            * int: The position in 'self' to get.
            * slice: A slice object, where 'start', 'stop', and 'step' are
              integers or None
            * ndarray: A 1-d boolean NumPy ndarray the same length as 'self'

        Returns
        -------
        item : scalar or ExtensionArray

        Notes
        -----
        For scalar ``item``, return a scalar value suitable for the array's
        type. This should be an instance of ``self.dtype.type``.
        For slice ``key``, return an instance of ``ExtensionArray``, even
        if the slice is length 0 or 1.
        For a boolean mask, return an instance of ``ExtensionArray``, filtered
        to the values where ``item`` is True.
        r�)�pyarrow�
pyarrow_numpyr\�iu�bzFOnly integers, slices and integer or boolean arrays are valid indices.Nzuonly integers, slices (`:`), ellipsis (`...`), numpy.newaxis (`None`) and integer or boolean arrays are valid indicesrr�)&r+r�rr	�lenr��name�storagerTr�r�rVr�r�r�taker��filter�
IndexError�tupler,�Ellipsis�slicerr�start�stop�stepr��as_pyrrUr�r�rrr�r)r��itemr�r�r�rcs      r?�__getitem__zArrowExtensionArray.__getitem__ sg��0#�4��.���d�B�J�J�'��t�9��;�;�#�#�x�/�D�K�K�4G�4G�L�5� "�y�y�{�H�#�{�{�8�8�H�!�t�D�z�"�"2�"2�2�H�"E�F�F������D�(��y�y���&������C�'�!�t�D�z�$�.�.�"7�"7��"=�>�>� �8�����e�
$�,�T�2�D��8����;�D��T�?�:�d�#3��L��
��d�E�"��z�z�T�Y�Y�&���	�	�%��I�I��T��
�*��I�I�)��I�I��M��T�Z�Z��t�y�y�9�����t�$���e�R�_�_�-��4��:�e�$�$��n�n�)�)�G��[�[�]�F��~��{�{�+�+�+����&�&�w�/�G�L�L�D�4H� ��(�0�0����>�>����%�%�g�.�7�<�<�4�3G� ��(�0�0����>�>��
rAc#� K�|jj}|jj}tj
j
|�xr|jdk7}tj
j|�xr|jdk7}|jD]o}|j�}|�|���|r't|�j|j����C|r't|�j|j����l|���qy�w)z5
        Iterate over elements of the array.
        r�N)
r�rr�rVrTrUr�r�r�r%rrr)r�rr��
box_timestamp�
box_timedeltar��vals       r?�__iter__zArrowExtensionArray.__iter__{s������;�;�'�'���.�.�%�%�����-�-�g�6�O�7�<�<�4�;O�
����,�,�W�5�N�'�,�,�$�:N�
��^�^�E��+�+�-�C��{������n�,�,�W�\�\�:�:����n�,�,�W�\�\�:�:��	�$�s�DDc��|jS)z)Convert myself to a pyarrow ChunkedArray.)r�)r�rVs  r?rz#ArrowExtensionArray.__arrow_array__�s���~�~�rAc�&�|j|��S)z?Correctly construct numpy arrays when passed to `np.asarray()`.r�)r
)r�r�r�s   r?�	__array__zArrowExtensionArray.__array__�s���}�}�5�}�)�)rAc��tjj|jj�r.t	|�tj|j��Stjj|jj�s3tjj|jj�rtd��t	|�tj|j��S)Nz-__invert__ is not supported for string dtypes)rTrUrr�rVr:�bit_wise_notr�r��	TypeError�invert�r�s r?�
__invert__zArrowExtensionArray.__invert__�s���
�8�8���t�~�~�2�2�3��4��:�b�o�o�d�n�n�=�>�>�
�X�X�
�
���� 3� 3�
4����8P�8P��N�N���9
��K�L�L��4��:�b�i�i����7�8�8rAc�^�t|�tj|j��Sr9)rVr:�negate_checkedr�r4s r?�__neg__zArrowExtensionArray.__neg__�s"���t�D�z�"�+�+�D�N�N�;�<�<rAc�8�t|�|j�Sr9�rVr�r4s r?�__pos__zArrowExtensionArray.__pos__�s���t�D�z�$�.�.�)�)rAc�^�t|�tj|j��Sr9)rVr:�abs_checkedr�r4s r?�__abs__zArrowExtensionArray.__abs__�� ���t�D�z�"�.�.����8�9�9rAc�t�|jj�}|jj�|d<|S)Nr�)�__dict__r�r��combine_chunks)r��states  r?�__getstate__z ArrowExtensionArray.__getstate__�s0���
�
�"�"�$��!�^�^�:�:�<��k���rAc��d|vr|jd�}n|d}tj|�|d<|jj	|�y)N�_datar�)�poprTr�rA�update)r�rC�datas   r?�__setstate__z ArrowExtensionArray.__setstate__�sI���e���9�9�W�%�D���%�D��-�-�d�3��k���
�
���U�#rAc���t|j}t|ttj
ttf�stt|dd�t�r-||j|j|��}t|�St|�r.	||j|j|��}t|�St7|j�dt9|�����#tjjtjj f$r�t#|�t#|�z}|}t	j$t'|�d��}t	j(|�}	||||�||<n&#t*$rt-j.|||�}YnwxYwtj(|tj0���}t3j4||d�}Yt|�SwxYw)Nr��boolr�r\z not implemented for )�ARROW_CMP_FUNCS�__name__r�r�rr	�listr)�getattrrr�r�rrTr	r�r�r�zerosrr�r2r!�invalid_comparisonr�r:rdr�rV)r��other�op�pc_funcrmr��valid�np_arrays        r?�_cmp_methodzArrowExtensionArray._cmp_method�s���!�"�+�+�.����'����T�?�K�
�
���w��5�7G�
H��T�^�^�T�\�\�%�-@�A�F�&#�6�*�*�%�u�
�
9� �������e�1D�E�� #�6�*�*�&��;�;�-�4�T�%�[�M�B��
���F�F�3�3�R�V�V�5H�5H�I�

9��D�z�D��K�/��������#�d�)�6�:���8�8�D�>��I�$&�x����$>�F�5�M�� �I� �3�3�H�e�R�H�F�I�����&�r�x�x�z�:�����E�6�4�8��
#�6�*�*�

9�s8�"C"�"BG,�)E9�8G,�9 F�G,�F�AG,�+G,c��|jj}|j|�}tjj|�s?tjj
|�s tjj|��rh|tjtjfvr�tjd|��}|tjur"tj|j||�}n3|tjur!tj||j|�}t|��S|tjtj fv�r�|j}|}tjj#|j�st%d��tj&tj(|d�d|�}	tj*||	�}t|�|�Stjj|j�sRtjj|j�s)tjj
|j�r�|tjtj fvr�|}|j}tjj#|j�st%d��tj&tj(|d�d|�}	tj*||	�}t|�|�St-|tj.�rFtj0|�j3�r#|j4t6vr|j9|�}||j4}
|
t:urt=|j4�d���|
|j|�}t|�|�S)N�r\z'Can only string multiply by an integer.rz not implemented.)r�rVr�rTrUr�r�r��operatorror"rprcr:�binary_join_element_wiserxryrr2rdrb�
binary_repeatr�r��is_nullr%rN�ARROW_LOGICAL_FUNCSr�NotImplementedr�)r�rSrT�arrow_funcsr��seprm�binary�integral�pa_integralrUs           r?�_evaluate_op_methodz'ArrowExtensionArray._evaluate_op_method�s����.�.�%�%�����U�#��
�H�H���w�'��x�x�'�'��0��x�x�!�!�'�*��h�l�l�I�N�N�3�3��i�i���1������%��8�8�����PS�T�F��9�>�>�)��8�8�����PS�T�F�!�t�D�z�&�)�)�����i�n�n�5�5����� ���x�x�*�*�8�=�=�9�#�$M�N�N� �j�j�����1�)=�q�(�K���)�)�&�+�>��!�t�D�z�&�)�)��H�H���u�z�z�*��x�x�!�!�%�*�*�-��x�x�'�'��
�
�3��X�\�\�9�>�>�2�2��F��~�~�H��8�8�&�&�x�}�}�5�� I�J�J��*�*�R�W�W�X�q�%9�1�h�G�K��%�%�f�k�:�F��4��:�f�%�%��u�b�i�i�(��
�
�5�!�'�'�)����2�2��J�J�w�'�E��b�k�k�*���n�$�%����
�5F�&G�H�H������/���t�D�z�&�!�!rAc���tjj|jj�r|j||t�S|j||t�Sr9)rTrUrr�rVrf�ARROW_BIT_WISE_FUNCSr_�r�rSrTs   r?�_logical_methodz#ArrowExtensionArray._logical_method
sL���8�8���t�~�~�2�2�3��+�+�E�2�7K�L�L��+�+�E�2�7J�K�KrAc�0�|j||t�Sr9)rf�ARROW_ARITHMETIC_FUNCSris   r?�
_arith_methodz!ArrowExtensionArray._arith_methods���'�'��r�3I�J�JrAc�V�t|t�sy|j|jk(S�NF)r�r�r�)r�rSs  r?�equalszArrowExtensionArray.equalss%���%�!4�5���~�~����0�0rAc��|jS)z2
        An instance of 'ExtensionDtype'.
        )r�r4s r?r�zArrowExtensionArray.dtypes��
�{�{�rAc�.�|jjS)zL
        The number of bytes needed to store this object in memory.
        )r��nbytesr4s r?rszArrowExtensionArray.nbytes#s��
�~�~�$�$�$rAc�,�t|j�S)z]
        Length of this array.

        Returns
        -------
        length : int
        )rr�r4s r?�__len__zArrowExtensionArray.__len__*s���4�>�>�"�"rAc�X��t|�r�||jjuro|jjdk(rUt	j
|�r@t
jt
j|j��j�Sytt�|�5|��S)N�fF)rr�rrr	�is_floatr:�any�is_nanr�r%rL�super�__contains__)r��key�	__class__s  �r?r|z ArrowExtensionArray.__contains__4sw�����9��D�J�J�$7�$7�7��z�z���#�%�#�,�,�s�*;��v�v�b�i�i����7�8�>�>�@�@���E�G�(��-�.�.rAc�4�|jjdkDS)Nr)r�rr4s r?�_hasnazArrowExtensionArray._hasna@s���~�~�(�(�1�,�,rAc�\�|jj}|dk(r.tjt	|�tj
��S|t	|�k(r.tjt	|�tj
��S|jj�j�S)z�
        Boolean NumPy array indicating if each value is missing.

        This should return a 1-D array the same length as 'self'.
        rr�)	r�rrrQrr��onesr^r
)r�rs  r?rzArrowExtensionArray.isnaDst���^�^�.�.�
���?��8�8�C��I�R�X�X�6�6�
�3�t�9�
$��7�7�3�t�9�B�H�H�5�5��~�~�%�%�'�0�0�2�2rAT��skipnac�*�|jdd|i|��S)a
        Return whether any element is truthy.

        Returns False unless there is at least one element that is truthy.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be False, as for an empty array.
            If `skipna` is False, the result will still be True if there is
            at least one element that is truthy, otherwise NA will be returned
            if there are NA's present.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        ArrowExtensionArray.all : Return whether all elements are truthy.

        Examples
        --------
        The result indicates whether any element is truthy (and by default
        skips NAs):

        >>> pd.array([True, False, True], dtype="boolean[pyarrow]").any()
        True
        >>> pd.array([True, False, pd.NA], dtype="boolean[pyarrow]").any()
        True
        >>> pd.array([False, False, pd.NA], dtype="boolean[pyarrow]").any()
        False
        >>> pd.array([], dtype="boolean[pyarrow]").any()
        False
        >>> pd.array([pd.NA], dtype="boolean[pyarrow]").any()
        False
        >>> pd.array([pd.NA], dtype="float64[pyarrow]").any()
        False

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, False, pd.NA], dtype="boolean[pyarrow]").any(skipna=False)
        True
        >>> pd.array([1, 0, pd.NA], dtype="boolean[pyarrow]").any(skipna=False)
        True
        >>> pd.array([False, False, pd.NA], dtype="boolean[pyarrow]").any(skipna=False)
        <NA>
        >>> pd.array([0, 0, pd.NA], dtype="boolean[pyarrow]").any(skipna=False)
        <NA>
        r�)ry��_reduce�r�r��kwargss   r?ryzArrowExtensionArray.anyS���p�t�|�|�;�&�;�F�;�;rAc�*�|jdd|i|��S)a
        Return whether all elements are truthy.

        Returns True unless there is at least one element that is falsey.
        By default, NAs are skipped. If ``skipna=False`` is specified and
        missing values are present, similar :ref:`Kleene logic <boolean.kleene>`
        is used as for logical operations.

        Parameters
        ----------
        skipna : bool, default True
            Exclude NA values. If the entire array is NA and `skipna` is
            True, then the result will be True, as for an empty array.
            If `skipna` is False, the result will still be False if there is
            at least one element that is falsey, otherwise NA will be returned
            if there are NA's present.

        Returns
        -------
        bool or :attr:`pandas.NA`

        See Also
        --------
        ArrowExtensionArray.any : Return whether any element is truthy.

        Examples
        --------
        The result indicates whether all elements are truthy (and by default
        skips NAs):

        >>> pd.array([True, True, pd.NA], dtype="boolean[pyarrow]").all()
        True
        >>> pd.array([1, 1, pd.NA], dtype="boolean[pyarrow]").all()
        True
        >>> pd.array([True, False, pd.NA], dtype="boolean[pyarrow]").all()
        False
        >>> pd.array([], dtype="boolean[pyarrow]").all()
        True
        >>> pd.array([pd.NA], dtype="boolean[pyarrow]").all()
        True
        >>> pd.array([pd.NA], dtype="float64[pyarrow]").all()
        True

        With ``skipna=False``, the result can be NA if this is logically
        required (whether ``pd.NA`` is True or False influences the result):

        >>> pd.array([True, True, pd.NA], dtype="boolean[pyarrow]").all(skipna=False)
        <NA>
        >>> pd.array([1, 1, pd.NA], dtype="boolean[pyarrow]").all(skipna=False)
        <NA>
        >>> pd.array([True, False, pd.NA], dtype="boolean[pyarrow]").all(skipna=False)
        False
        >>> pd.array([1, 0, pd.NA], dtype="boolean[pyarrow]").all(skipna=False)
        False
        r�)�allr�r�s   r?r�zArrowExtensionArray.all�r�rA�	quicksort�last)�	ascendingr�na_positionc��|rdnd}ddd�j|d�}|�td|����tj|j||��}|j�}|j
tjd�	�S)
Nr��
descending�at_end�at_start)r��firstzinvalid na_position: )�order�null_placementF�r�)	�getr�r:�array_sort_indicesr�r
�astyper�intp)	r�r�rr�r�r�r�rm�	np_results	         r?�argsortzArrowExtensionArray.argsort�s��� )��l��"*�Z�@�D�D�[�RV�W���!��4�[�M�B�C�C��&�&��N�N�%��
���O�O�%�	�������e��4�4rAc����|jj�d|jjfvs|jr |st	t�d|���|��S|j}tjj|j�r#|jt
j��}t	t|�||��}tj||�j�S)Nr�argr�)�
skip_nulls)r��lengthrr�rPr{rTrUr�rVrr�r:�indexr%)r�r��methodrIr�r~s     �r?�_argmin_maxzArrowExtensionArray._argmin_max�s�����>�>� � �"�q�$�.�.�*C�*C�&D�D��K�K��
4�7�5�7�c�&��N�3�6�B�B��~�~��
�8�8����	�	�*��9�9�R�X�X�Z�(�D�#���F�#�D�V�<���x�x��e�$�*�*�,�,rAc�&�|j|d�S)N�min�r��r�r�s  r?�argminzArrowExtensionArray.argmin���������.�.rAc�&�|j|d�S)N�maxr�r�s  r?�argmaxzArrowExtensionArray.argmax�r�rAc�8�t|�|j�S)z�
        Return a shallow copy of the array.

        Underlying ChunkedArray is immutable, so a deep copy is unnecessary.

        Returns
        -------
        type(self)
        r:r4s r?r�zArrowExtensionArray.copy�s���t�D�z�$�.�.�)�)rAc�^�t|�tj|j��S)z|
        Return ArrowExtensionArray without NA values.

        Returns
        -------
        ArrowExtensionArray
        )rVr:�	drop_nullr�r4s r?�dropnazArrowExtensionArray.dropna�s"���t�D�z�"�,�,�t�~�~�6�7�7rA)�limit�
limit_arear�c���|js|j�S|�|�}tj|�}	|dk(r.t	|�tj|j��S|dk(r.t	|�tj|j��S	t�|�1||||��S#tj$rY�(wxYw)N�pad�backfill)r�r�r�r�)
r�r�r �clean_fill_methodrVr:�fill_null_forwardr��fill_null_backwardrTr�r{�_pad_or_backfill)r�r�r�r�r�r~s     �r?r�z$ArrowExtensionArray._pad_or_backfills�����{�{��9�9�;���=�Z�/��.�.�v�6�F�

��U�?�%�4��:�b�&:�&:�4�>�>�&J�K�K��z�)�%�4��:�b�&;�&;�D�N�N�&K�L�L�*��w�'���:�D�(�
�	
���.�.�
�
�
�s�2B2�+2B2�2C�Cc����t||�\}}|js|j�S|�t�|�||||��S|�t�|�|||��St|tjtf�r:t|�t|�k7r#tdt|��dt|�����	|j||jj��}	t|�t'j(|j|���S#tj$r,}dt!|��d|j"��}t%|�|�d}~wwxYw#tj*$rYnwxYwt�|�||||��S)	N)r�r�r�r�)r�r�r�z'Length of 'value' does not match. Got (z)  expected )r��Invalid value '�' for dtype )�
fill_value)rr�r�r{rr�rr	r'rr�r�r�rVrTrr�r�r2r:�	fill_nullr�)	r�r�r�r�r�r��errr�r~s	        �r?rzArrowExtensionArray.fillna&sj���/�u�f�=�
��v��{�{��9�9�;�����7�>��f�E�PT�>�U�U����7�>��u�4�>�H�H��e�b�j�j�.�9�:��5�z�S��Y�&� �=�c�%�j�\�J!�!$�T���-���
	*����e�T�^�^�5H�5H��I�J�
	��4��:�b�l�l�4�>�>�j�Q�R�R��� � �	*�#�C��J�<�|�D�J�J�<�H�C��C�.�c�)��	*���*�*�	�

�	���w�~�E�&��D�~�Q�Qs*�1'D	�/E�	E�'E�E�E!� E!c��t|�s$tjt|�t��St	j
|jtj|d����}tj|tj��S)Nr�Tr)�	value_set)
rrrQrLr:�is_inr�rTr�r�)r�r�rms   r?�isinzArrowExtensionArray.isinTsU���6�{��8�8�C��I�T�2�2����$�.�.�B�H�H�V�QU�4V�W���x�x��b�h�h�/�/rAc�f�|jj�}||jjfS)a+
        Return an array and missing value suitable for factorization.

        Returns
        -------
        values : ndarray
        na_value : pd.NA

        Notes
        -----
        The values returned by this method are also used in
        :func:`pandas.util.hash_pandas_object`.
        )r�r
r�r)r�r�s  r?�_values_for_factorizez)ArrowExtensionArray._values_for_factorize^s+�����(�(�*���t�z�z�*�*�*�*rAc���|rdnd}|j}|j}trBtjj|�r#|j
tj��}tjj|j�r|}n|j|��}|j�dk(r`tjgtj��}t|�tjg|jj���}n�|j!�}|j"}	|	j$dkDrt'j(|	d�}	|	j+dd	�
�j-tjd��}t|�|j.�}trHtjj|�r)t
t0|j-|j2��}||fS)Nr��encode)�
null_encodingrr�r\r�FT)�zero_copy_only�writabler�)r�rVrrTrUr�rr�rrr�rr�r�r��
value_typerB�indicesrr:r�r
r��
dictionaryr�r�)
r��use_na_sentinelr�rIr��encodedr��uniques�combined�
pa_indicess
          r?�	factorizezArrowExtensionArray.factorizeosx��
#2��x�
��~�~���)�)���B�H�H�$8�$8��$A��9�9�R�X�X�Z�(�D�
�8�8�!�!�$�)�)�,��G��,�,�=�,�I�G��>�>��q� ��h�h�r����1�G� �d�4�j��!1�!1�"�7�<�<�;R�;R�!S�T�G��-�-�/�H�!�)�)�J��$�$�q�(��\�\�*�b�9�
� �)�)���)�N�U�U����e�V��G�!�d�4�j��!4�!4�5�G��B�H�H�$8�$8��$A��.����t�z�z�0J�K�G����rAc�0�tt|��d���)NzA does not support reshape as backed by a 1D pyarrow.ChunkedArray.)r�rV)r��argsr�s   r?�reshapezArrowExtensionArray.reshape�s"��!��D�z�l�6�
7�
�	
rArc�b�t|�tj|j|���S)a�
        Round each value in the array a to the given number of decimals.

        Parameters
        ----------
        decimals : int, default 0
            Number of decimal places to round to. If decimals is negative,
            it specifies the number of positions to the left of the decimal point.
        *args, **kwargs
            Additional arguments and keywords have no effect.

        Returns
        -------
        ArrowExtensionArray
            Rounded values of the ArrowExtensionArray.

        See Also
        --------
        DataFrame.round : Round values of a DataFrame.
        Series.round : Round values of a Series.
        )�ndigits)rVr:�roundr�)r��decimalsr�r�s    r?r�zArrowExtensionArray.round�s$��,�t�D�z�"�(�(�4�>�>�8�D�E�ErAc���|jrtd��t|t�r|j	t
�}d}t|jt�ri|jj}tjj|�stjj|�r|jdk(rt
}|j|��j|||��S)NzOsearchsorted requires array to be sorted, which is impossible with NAs present.r�r�)�side�sorter)r�r�r�r'r��objectr�r1r�rTrUr�r�r�r
�searchsorted)r�r�r�r�r�r�s      r?r�z ArrowExtensionArray.searchsorted�s����;�;��$��
��e�^�,��L�L��(�E����d�j�j�*�-��z�z�/�/�H����%�%�h�/�2�8�8�3G�3G��3Q��-�-�4�'����}�}�5�}�)�6�6�u�4�PV�6�W�WrAc��tj|�}t|j�dk(r|dk\j	�rtd��|jdkDr1|j�t|j�k\rtd��|r�|dk}|j	�r�t|t|j��tj||��}|jj|�}t|�rt|�|�St|�|�}|||<|St|�|jj|��S|dkj	�r8tj|�}||dkxxt|j�z
cc<t|�|jj|��S)a�
        Take elements from an array.

        Parameters
        ----------
        indices : sequence of int or one-dimensional np.ndarray of int
            Indices to be taken.
        allow_fill : bool, default False
            How to handle negative values in `indices`.

            * False: negative values in `indices` indicate positional indices
              from the right (the default). This is similar to
              :func:`numpy.take`.

            * True: negative values in `indices` indicate
              missing values. These values are set to `fill_value`. Any other
              other negative values raise a ``ValueError``.

        fill_value : any, optional
            Fill value to use for NA-indices when `allow_fill` is True.
            This may be ``None``, in which case the default NA value for
            the type, ``self.dtype.na_value``, is used.

            For many ExtensionArrays, there will be two representations of
            `fill_value`: a user-facing "boxed" scalar, and a low-level
            physical NA value. `fill_value` should be the user-facing version,
            and the implementation should handle translating that to the
            physical version for processing the take if necessary.

        Returns
        -------
        ExtensionArray

        Raises
        ------
        IndexError
            When the indices are out of bounds for the array.
        ValueError
            When `indices` contains negative values other than ``-1``
            and `allow_fill` is True.

        See Also
        --------
        numpy.take
        api.extensions.take

        Notes
        -----
        ExtensionArray.take is called by ``Series.__getitem__``, ``.loc``,
        ``iloc``, when `indices` is a sequence of values. Additionally,
        it's called by :meth:`Series.reindex`, or any other method
        that causes realignment, with a `fill_value`.
        rzcannot do a non-empty takez!out of bounds value in 'indices'.�r�)r�
asanyarrayrr�ryr�sizer�r-rTr�rrrVr�)r�r��
allow_fillr��
indices_array�	fill_maskrms       r?rzArrowExtensionArray.take�s{��v�
�
�g�.�
��t�~�~��!�#��!�);�(@�(@�(B��9�:�:�����!�m�&7�&7�&9�S����=P�&P��@�A�A��%��)�I��}�}�� ���D�N�N�0C�D� "����Y� G�
����,�,�]�;���
�#�%�4��:�f�-�-�$��d��F�+��$.��y�!��
�"�t�D�z�$�.�.�"5�"5�g�">�?�?���!�&�&�(� "���
� 6�
��m�a�/�0�C����4G�G�0��4��:�d�n�n�1�1�-�@�A�ArAc���|jj}tjj	|�r|j�Stjj
|�r|j�S|S)z"Maybe convert to a datelike array.)r�rVrTrUr��_to_datetimearrayr��_to_timedeltaarray)r�r�s  r?�_maybe_convert_datelike_arrayz1ArrowExtensionArray._maybe_convert_datelike_array&sX���.�.�%�%��
�8�8� � ��)��)�)�+�+�
�X�X�
!�
!�'�
*��*�*�,�,��rAc�~�ddlm}m}|jj}t
jj|�sJ�tjd|j�d��}||j|j�}|jj�}|j|�}|j||��S)z;Convert a pyarrow timestamp typed array to a DatetimeArray.r)r��tz_to_dtypezM8[�]r�)�pandas.core.arrays.datetimesr�r�r�rVrTrUr�rr�r�r�r
r��_simple_new)r�r�r�r��np_dtyper�rWs       r?r�z%ArrowExtensionArray._to_datetimearray/s���	
�
�.�.�%�%���x�x�$�$�W�-�-�-��8�8�c�'�,�,��q�1�2���G�J�J����5���>�>�*�*�,���?�?�8�,��(�}�(�(���?�?rAc�@�ddlm}|jj}tj
j
|�sJ�tjd|j�d��}|jj�}|j|�}|j||��S)z;Convert a pyarrow duration typed array to a TimedeltaArray.rr�zm8[r�r�)
�pandas.core.arrays.timedeltasr�r�rVrTrUr�rr�r�r
r�r�)r�r�r�r�rWs     r?r�z&ArrowExtensionArray._to_timedeltaarray>s|��@��.�.�%�%���x�x�#�#�G�,�,�,��8�8�c�'�,�,��q�1�2���>�>�*�*�,���?�?�8�,��)�~�)�)�(�(�C�CrAc���t|j�rtj|t��St
�|��S�Nr�)rr�r�asarrayr�r{�_values_for_json)r�r~s �r?r�z$ArrowExtensionArray._values_for_jsonIs.����D�J�J�'��:�:�d�&�1�1��w�'�)�)rAc�T�|}t||||j�\}}|jj}|jr*t	|�st
jj|�r|}n|j|�}d}t
jj|�st
jj|�rT|tk7r(||jjurtj}|j!�j#||��}|St
jj%|�st
jj'|�rAt)j*t-|�|��}|jr|||j	�<|St
jj|�r2|�
t	|�rd}t)j.t1|�||��}|S|jrNt
jj3|�rr|t(j4us|tjurNt7|�rC|jj#�}|�|j9|d��}|r|j;�}|S|�Ptj*g|��j#d��}t=||�r
|j}nt(j>}t)j@t1|�|��}|j	�}	|||	<||	jj#�||	<|S)NF�r�rr�)r�r�r�r\�r�)!r&r�r�rVrrTrUr^rr�r�r�r�rr	�
no_defaultr�r
r�r�rr�rO�fullrr��nanrr�r�r�object_�empty)
r�r�r�r�original_na_valuer�rIrmrr�s
          r?r
zArrowExtensionArray.to_numpyNs}��%��2�4���$�+�+�V���x��.�.�%�%���{�{�d�8�n����0@�0@��0I��D��;�;�x�(�D��D�
�8�8� � ��)�R�X�X�-A�-A�'�-J����8�t�z�z�/B�/B�#B��>�>���7�7�9�B�B��h�C��F�J�
�E�X�X�
�
�g�
&�"�(�(�*:�*:�7�*C��X�X�d�4�j��6�F��{�{�&.��t�y�y�{�#�:�
�9�X�X�
�
�g�
&�� �T�(�^����W�W�S��Y�8�5�I�F�2�
�1����H�H� � ��)��B�F�F�"�$����6�"�5�)��^�^�,�,�.�F�� ����u�5��9���������
��}�����'�2�;�;�5�;�Q��#�E�8�4�!�K�K�E��J�J�E��X�X�c�$�i�u�5�F��9�9�;�D�#�F�4�L� �$��K�1�1�:�:�<�F�D�5�M��
rAc���t|j�rt|j�||��St�|�||�S)N)�	na_action)rr�r#r
r{�map)r��mapperrr~s   �r?rzArrowExtensionArray.map�s5����D�J�J�'��T�]�]�_�f�	�J�J��7�;�v�y�1�1rA�keepc���|jj}tjj	|�stjj|�r|j
d��}n�tjj|�r|j
d��}n�tjj|�re|jdk(rtj�}ntj�}|jt|��}|j
d��}n|j�d}|jr|j!�nd}t#j$|||��S)Nr)rF� )rr�)r�rVrTrUr�rr
r��is_temporal�	bit_width�int32r�r�r1r�r�r�algos�
duplicated)r�rr�r�r�r�s      r?r
zArrowExtensionArray.duplicated�s����.�.�%�%��
�8�8����(�B�H�H�,?�,?��,H��]�]�A�]�.�F�
�X�X�
 �
 ��
)��]�]�E�]�2�F�
�X�X�
!�
!�'�
*�� � �B�&��(�(�*���(�(�*���+�+�j��1�2�C��\�\�1�\�-�F��^�^�%�a�(�F�"�k�k�t�y�y�{�t������T��=�=rAc��|jj}trMtjj|�r.|jj
tj��}n|j}tj|�}tr0tjj|�r|j
|�}t|�|�S)z�
        Compute the ArrowExtensionArray of unique values.

        Returns
        -------
        ArrowExtensionArray
        )
r�rVrrTrUr�rr�r:�unique)r�r�rI�	pa_results    r?rzArrowExtensionArray.unique�s����.�.�%�%���B�H�H�$8�$8��$A��>�>�&�&�r�x�x�z�2�D��>�>�D��I�I�d�O�	��B�H�H�$8�$8��$A�!���w�/�I��t�D�z�)�$�$rAc��|jj}trMtjj|�r.|jj
tj��}n|j}ddlm	}m
}|j�}|jd�}|jd�}|rA|jdkDr2|j�}	|j|	�}|j|	�}tr0tjj|�r|j
|�}t!|�}|t|�|��}
|||
dd��S)a@
        Return a Series containing counts of each unique value.

        Parameters
        ----------
        dropna : bool, default True
            Don't include counts of missing values.

        Returns
        -------
        counts : Series

        See Also
        --------
        Series.value_counts
        r)�Indexr�r]�countF)r�rr�)r�rVrrTrUr�rr��pandasrr��value_counts�fieldr�is_validrr�)r�r�r�rIrr��vcr��countsr�r�s           r?rz ArrowExtensionArray.value_counts�s��"�.�.�%�%���B�H�H�$8�$8��$A��>�>�&�&�r�x�x�z�2�D��>�>�D�	
�
�
�
�
 �����!������!����d�o�o��)��?�?�$�D��]�]�4�(�F��]�]�4�(�F��B�H�H�$8�$8��$A��[�[��)�F�$�V�,���j�d�4�j��(�)���f�E��e�D�DrAc�,�|D��cgc]#}|jj�D]}|���%}}}|djdk(rtj�}n|djj
}tj||��}||�Scc}}w)z�
        Concatenate multiple ArrowExtensionArrays.

        Parameters
        ----------
        to_concat : sequence of ArrowExtensionArrays

        Returns
        -------
        ArrowExtensionArray
        rr�r\)r��
iterchunksr�rT�large_stringr�r�)r��	to_concat�ear��chunksr�r�s       r?�_concat_same_typez%ArrowExtensionArray._concat_same_type�s���#,�S�)�B����9P�9P�9R��%�9R�%�)��S��Q�<����)����(�H� ��|�)�)�7�7�H����v�H�5���3�x���Ts�(Bc�T��ddddd�j||�}tt|d�}|�t�
|�|fd|i|��S|j
}|j}tjj|�xr|dvxs&tjj|�xr|d	k(}|rV|jd
k(r$|jtj��}n#|jtj��}||fd|i|��}	|r|	j|�}	t
|�|	�S)a�
        Return an ExtensionArray performing an accumulation operation.

        The underlying data type might change.

        Parameters
        ----------
        name : str
            Name of the function, supported values are:
            - cummin
            - cummax
            - cumsum
            - cumprod
        skipna : bool, default True
            If True, skip NA values.
        **kwargs
            Additional keyword arguments passed to the accumulation function.
            Currently, there is no supported kwarg.

        Returns
        -------
        array

        Raises
        ------
        NotImplementedError : subclass does not define accumulations
        �cumulative_max�cumulative_min�cumulative_prod_checked�cumulative_sum_checked)�cummax�cummin�cumprod�cumsumNr�)r&r'r)rr�)r�rPr:r{�_accumulater�rVrTrUr	r�r
rrr�)r�rr�r��pyarrow_name�pyarrow_meth�
data_to_accumr��convert_to_intrmr~s          �r?r*zArrowExtensionArray._accumulates'���>'�&�0�.�	
�
�#�d�D�/�	��r�<��6�����7�&�t�E�F�E�f�E�E����
� �%�%��
�H�H� � ��*�K�t�7K�/K�C��h�h�"�"�8�,�A���1A�	���!�!�R�'� -� 2� 2�2�8�8�:� >�
� -� 2� 2�2�8�8�:� >�
��m�I��I�&�I����[�[��*�F��t�D�z�&�!�!rAc�
����jj}�j}trinddi}|dvr�tjj|�s]tjj
|�s>tjj|�stjj|�rrtjj|�r.�jjtj��}n�j}tj|d�}|}n�|dvrMtjj|�r.�jjtj��}n�|dvr�tjj|�rl|j}	|	dk(r.�jjtj��}n-�jjtj��}|dk(r�fd	�}
n<d
ddd
d�j!||�}t#t|d�}
|
�t%���L|fd|i|��S|dvr
d|vrd|d<n
|dk(rd|d<	|
|fd|i|��}|dk(r|d}tj4|�j7�r|S|dvr0tjj|�r|j|�}|dvr�tjj|�rsts\|j}	|	dk(r&|jtj�fi|��}n%|jtj�fi|��}|j|�}|dv�r:tjj|��r|jtj�fi|��}tjj|�r|j|�}|Stjj9|�r1t;|�}|jtj<|��}|Stjj?|�r&|jtj<d��}|S|jtj<|j@��}|S#t(t*t,f$rN}
dt��j.�d�j0�d|�dtj2�d|�d�}t-|�|
�d}
~
wwxYw)a�
        Return a pyarrow scalar result of performing the reduction operation.

        Parameters
        ----------
        name : str
            Name of the function, supported values are:
            { any, all, min, max, sum, mean, median, prod,
            std, var, sem, kurt, skew }.
        skipna : bool, default True
            If True, skip NaN values.
        **kwargs
            Additional keyword arguments passed to the reduction function.
            Currently, `ddof` is the only supported kwarg.

        Returns
        -------
        pyarrow scalar

        Raises
        ------
        TypeError : subclass does not define reductions
        rSF)ryr�r)r�r��sum)�median�mean�std�semrr4c����tj|fd|i|��}tjtj�j��}tj
||�S)Nr�)r:�stddev�sqrt_checkedrr�r^)rIr�r��	numerator�denominatorr�s     �r?r,z9ArrowExtensionArray._reduce_pyarrow.<locals>.pyarrow_meth{sI����I�I�d�L�z�L�V�L�	� �o�o�b�h�h�t�~�~�.F�G���(�(��K�@�@rA�quantile�productr6�variance)r1�prodr3�varNr��	min_countr1g�?�qr��'z
' with dtype z does not support reduction 'z' with pyarrow version z. 'z(' may be supported by upgrading pyarrow.)r1r2)r3r4r�)!r�rVrrTrUrr�r�r�rr�r:r`r	r
rr�rPr{r��AttributeErrorr�r2rNr��__version__r^r%r�r�r�r�r�)r�rr�r�r��data_to_reduce�cast_kwargs�data_to_cmp�not_eq�nbitsr,r+rmr�r�r�r~s`               �r?�_reduce_pyarrowz#ArrowExtensionArray._reduce_pyarrow@s'���0�.�.�%�%������0�b�v�u�o���>�!��H�H����(��x�x�#�#�G�,��x�x�#�#�G�,��x�x�"�"�7�+�
�x�x�#�#�G�,�"�n�n�1�1�"�(�(�*�=��"�n�n���\�\�+�q�1�F�#�N�
�*�
*�r�x�x�/C�/C�G�/L�!�^�^�0�0�����<�N�
�5�
5�"�(�(�:N�:N�w�:W��%�%�E���{�!%���!4�!4�R�X�X�Z�!@��!%���!4�!4�R�X�X�Z�!@���5�=�
A�%�!��!�	�
�c�$��o�
�#�2�|�T�:�L��#��w��t�E�F�E�f�E�E��>�!�k��&?�"#�F�;��
�X�
��F�3�K�		*�!�.�N�V�N�v�N�F��8���A�Y�F�
�:�:�f��#�#�%��M��(�(�R�X�X�-A�-A�'�-J��[�[��)�F��%�%�"�(�(�*>�*>�w�*G�'��)�)���B�;�(�V�[�[�����C�{�C�F�(�V�[�[�����C�{�C�F��[�[��)�F��>�!�b�h�h�&:�&:�7�&C� �V�[�[�����;�{�;�F��x�x�#�#�G�,����W�-���
����!�!�'�*�-�g�6�����R�[�[��%6�7���
����!�!�'�*����R�[�[��%5�6��
�
� ���R�[�[����%>�?���
��M� 3�Y�?�	*��D��J�'�'�(�
�d�j�j�\�B/�/3�f�5��>�>�*�#�d�V�4%�&�
��C�.�c�)��	*�s�#R(�(T
�<A	T�T
�r��keepdimsc��|j|f||d�|��}t|tj�rt	|�|�S|S)a�
        Return a scalar result of performing the reduction operation.

        Parameters
        ----------
        name : str
            Name of the function, supported values are:
            { any, all, min, max, sum, mean, median, prod,
            std, var, sem, kurt, skew }.
        skipna : bool, default True
            If True, skip NaN values.
        **kwargs
            Additional keyword arguments passed to the reduction function.
            Currently, `ddof` is the only supported kwarg.

        Returns
        -------
        scalar

        Raises
        ------
        TypeError : subclass does not define reductions
        rJ)�_reduce_calcr�rTr�rV)r�rr�rKr�rms      r?r�zArrowExtensionArray._reduce�sF��4#��"�"�4�T���T�V�T���f�b�h�h�'��4��:�f�%�%��MrAc���|j|fd|i|��}|r{t|tj�r2tj|j�g|j��}|Stj|gtt|�d���}|Stj|�j�r|jjSt|tj�r|j�S|S)Nr�r\r)
rIr�rTr�r�r%rVr�rr:r^r�r)r�rr�rKr�rrms       r?rMz ArrowExtensionArray._reduce_calc�s���)�D�(�(��G�f�G��G�	���)�R�Y�Y�/����9�?�?�#4�"5�I�N�N�K���M�	����K�(�)@��)K�A�)N�O����M�
�:�:�i� �&�&�(��:�:�&�&�&�
�	�2�9�9�
-��?�?�$�$��rAc���tjj|jj�st
�|��S|}tjj|j�}|jd�j�}tjdg|jj��}|dk(}|j�r*|j�}|||<|j�}d||<|j!|�}t|�tjj#|j��}||fS)z-
        See Series.explode.__doc__.
        r]Nr\r)rTrU�is_listr�r�r{�_explode�compute�list_value_lengthr�r�r
rcrVryr�r�list_flatten)r�r�rr�r�r~s     �r?rQzArrowExtensionArray._explode�s�����x�x����
�
� 8� 8�9��7�#�%�%������-�-�f�.>�.>�?���!�!�!�$�-�-�/���Y�Y��v�D�N�N�,?�,?�@�
���{���8�8�:��[�[�]�F�%�F�4�L��[�[�]�F��F�4�L����z�*����d��B�J�J�3�3�F�4D�4D�E�F���v�~�rAc��t|t�rt|�dk(r|d}t||�}|j	|�}tj|�r|jd||j�}�n�t|��r
tt|�}t|�}|dkr||z
}d|cxkr|ksntd|�d|����t|tj�r|j�}nt!|�rt#d��g|jd|j$�tj&|g|jj(d���|j|dzdj$�}tj*|�j-�}�n�t/|�rDt1j2|t0j4�	�}|j7|j||�}�nCt9|�st|tj�rQt1j:t|�t0j4�	�}d||<|j|||j�}n�t1j<t|��|}t|�t|�k7rt#d��t|�dk(ryt1j>|�}||}|jA|�}t1j:t|�t0j4�	�}d||<|j7|j||�}t|tjB�rtj*|g�}||_y)
a�Set one or more values inplace.

        Parameters
        ----------
        key : int, ndarray, or slice
            When called from, e.g. ``Series.__setitem__``, ``key`` will be
            one of

            * scalar int
            * ndarray of integers.
            * boolean ndarray
            * slice object

        value : ExtensionDtype.type, Sequence[ExtensionDtype.type], or object
            value or values to be set of ``key``.

        Returns
        -------
        None
        r]rTzindex z' is out of bounds for axis 0 with size z%Length of indexer and values mismatchNr�r�)"r�rrr+�_maybe_convert_setitem_value�com�
is_null_slice�_if_elser�rr�intrrTr�r%rr�rr�rVr�rBrrr�r��_replace_with_maskrrQ�aranger�rr�)	r�r}r�rI�nrr�r�r�s	         r?�__setitem__zArrowExtensionArray.__setitem__s���,�c�5�!�c�#�h�!�m��a�&�C�!�$��,���1�1�%�8�����S�!��=�=��u�d�n�n�=�D�
��_��s�C�.�C��D�	�A��Q�w��q�����<�a�<� ��S�E�!H���L����%����+����
���e�$� �!H�I�I�������%�,�,�����%��t�~�~�':�':��M������a��	�*�1�1��F�
�#�#�F�+�:�:�<�D�
�3�
��*�*�S����1�C��*�*�4�>�>�3��F�D�
�u�
��E�2�9�9�!=��8�8�C��I�R�X�X�6�D��D��I��=�=��u�d�n�n�=�D��i�i��D�	�*�3�/�G��7�|�s�5�z�)� �!H�I�I��7�|�q� ���j�j��)�G��g�&�G��J�J�w�'�E��8�8�C��I�R�X�X�6�D� �D��M��*�*�4�>�>�4��G�D��d�B�H�H�%��#�#�T�F�+�D���rA�average��axisr��	na_optionr��pctc�`��|dk7r^t�|�|||||��}|dk(s|rtj�}ntj�}tj
||d��}|S|jj�}	|rdnd}
|dk(rd	nd
}|dk(rdn|}tj|	|
||��}|d
k(rWtj|j�}
tjd|j��}tj|
||�}|dk(r�tj|	|
|d��}|jtj��}|jtj��}tjtj ||�d�}|r�tj"j%|j�s#|jtj��}|dk(rtj&|�}ntj(|�}tj||�}|S)Nrr`r_Tr�r�r��topr�r�r�)�	sort_keysr��
tiebreakerrr\r���dense)r{�_rankrTrW�uint64r�r�rBr:�rankr^rcrVrdrrfrorUr�r�r)r�rar�rbr�rc�rankedr�rmrIrfr�rgr��null�
result_max�
result_min�divisorr~s                  �r?�
_rank_calczArrowExtensionArray._rank_calc[s�����1�9��W�]���#�#��#��F���"�c��*�*�,���)�)�+���X�X�f�7��E�F��M��~�~�,�,�.��#,�K�,�	�'0�E�'9��x��$�	�1�U�v�
������)�!�	
������:�:�d�n�n�-�D��9�9�T����4�D��Z�Z��d�F�3�F��Y������#�-� �	�J�$�������6�J����R�Z�Z�\�2�J��Y�Y�r�v�v�j�*�=�q�A�F���8�8�'�'����4����R�Z�Z�\�2���� ��&�&��.���(�(�6�*���Y�Y�v�w�/�F��
rAc	�L�t|�|j|||||���S)z*
        See Series.rank.__doc__.
        r`)rVrr)r�rar�rbr�rcs      r?rjzArrowExtensionArray._rank�s7���t�D�z��O�O���#�#��
�
�
�	
rAc��|jj}|j}tjj	|�rX|j
}|dk(r$|j
tj��}n#|j
tj��}tj|||��}tjj	|�r�tjj|j�rtj|�}|j
}|dk(r$|j
tj��}n#|j
tj��}|j
|�}t|�|�S)z�
        Compute the quantiles of self for each quantile in `qs`.

        Parameters
        ----------
        qs : np.ndarray[float64]
        interpolation: str

        Returns
        -------
        same type as self
        r)r@�
interpolation)
r�rVrTrUr	r
rrr�r:r:r�rg)r��qsrur�rIrHrms       r?�	_quantilezArrowExtensionArray._quantile�s���>�>�&�&���~�~��
�8�8����)��&�&�E���{��y�y�����,���y�y�����,�����T�R�}�E��
�8�8����)��x�x�#�#�F�K�K�0����&�)���&�&�E���{����R�X�X�Z�0�����R�X�X�Z�0���[�[��*�F��t�D�z�&�!�!rAc
�`�|jj}tjj	|�r}|j
}|dk(r.|jj
tj��}nJ|dk(r.|jj
tj��}nt|��|j}|r|j�}tj|�}|jd�jtj|jd�tj |jd����}tjj	|�r|j
|�}|j#tj$|��}t|�|�S)aT
        Returns the mode(s) of the ExtensionArray.

        Always returns `ExtensionArray` even if only one value.

        Parameters
        ----------
        dropna : bool, default True
            Don't consider counts of NA values.

        Returns
        -------
        same type as self
            Sorted, if possible.
        r�@r�r)r�rVrTrUr	r
rrr�r�r�r:rrrr�r�rr�)r�r�r�rHrI�res�most_commons       r?�_modezArrowExtensionArray._mode�s5�� �.�.�%�%��
�8�8����(��%�%�E���{��~�~�*�*�2�8�8�:�6���"���~�~�*�*�2�8�8�:�6��)�'�2�2��>�>�D���>�>�#�D��o�o�d�#���i�i��)�0�0��H�H�S�Y�Y�x�(�"�&�&����8�1D�*E�F�
���8�8����(�%�*�*�7�3�K�!�&�&�r�'<�'<�[�'I�J���t�D�z�+�&�&rAc���	|j||jj�}|S#tj$r,}dt|��d|j��}t|�|�d}~wwxYw)z-Maybe convert value to be pyarrow compatible.r�r�N)r�r�rVrTrr�r�r2)r�r�r�r�s    r?rVz0ArrowExtensionArray._maybe_convert_setitem_valuesf��	*��L�L�����(;�(;�<�E����� � �	*�#�C��J�<�|�D�J�J�<�H�C��C�.�c�)��	*�s�&*�A)�'A$�$A)c��|j�}	|jjdk(r|jj	�}
nD|jjdvr|j	dd��}
ntd|j����t
j|
f|d|||||	d�|��t|�|jtj|
|	�	���S)
z2
        See NDFrame.interpolate.__doc__.
        rwr�f8gr�z)interpolate is not implemented for dtype=r)r�rar�r��limit_directionr�r�r�)rr�rr�r
r�r �interpolate_2d_inplacerVr�rTr�)r�r�rar�r�r�r�r�r�r�rIs           r?�interpolatezArrowExtensionArray.interpolates��� �y�y�{���:�:�?�?�c�!��>�>�*�*�,�D�
�Z�Z�_�_��
$��=�=�t�c�=�:�D�%�;�D�J�J�<�H��
�	�&�&��
	
�����+�!��
	
��
	
��t�D�z�$�,�,�R�X�X�d��-F�G�H�HrAc��	tj|||�S#tj$rYnwxYwdd�}||�\}}||�\}}|xs|}t	j
|||�}tj||d��S)an
        Choose values based on a condition.

        Analogous to pyarrow.compute.if_else, with logic
        to fallback to numpy for unsupported types.

        Parameters
        ----------
        cond : npt.NDArray[np.bool_] or bool
        left : ArrayLike | Scalar
        right : ArrayLike | Scalar

        Returns
        -------
        pa.Array
        c��t|tjtjf�r
|j}n9t|tj
�r|j}|j
�}nd}tj|t��|fSr�)
r�rTr�r�rVr�r%rr�r�)r�r�s  r?�_to_numpy_and_typez8ArrowExtensionArray._if_else.<locals>._to_numpy_and_typeNs_���%�"�(�(�B�O�O�!<�=��*�*���E�2�9�9�-��*�*�����
�����8�8�E��0�'�9�9rATr�)�returnz%tuple[np.ndarray, pa.DataType | None])r:rdrTr�r�wherer�)	r��condrhrir��	left_type�
right_typer�rms	         r?rYzArrowExtensionArray._if_else2s���.	��:�:�d�D�%�0�0���*�*�	��	��	:�-�T�2���i�.�u�5���z��)�z�����$��e�,���x�x��W�$�?�?s��/�/c��t|tj�r|j�}t|tj�r9tjj|j�r|j�}	tj|||�S#tj$rYnwxYwt|tj�rtj|t��}n*t|tj�r|j�}tj|t��}|||<tj||jd��S)a�
        Replace items selected with a mask.

        Analogous to pyarrow.compute.replace_with_mask, with logic
        to fallback to numpy for unsupported types.

        Parameters
        ----------
        values : pa.Array or pa.ChunkedArray
        mask : npt.NDArray[np.bool_] or bool
        replacements : ArrayLike or Scalar
            Replacement value(s)

        Returns
        -------
        pa.Array or pa.ChunkedArray
        r�Tr�)r�rTr�rBrUr�rVr:�replace_with_maskr�r�rr�r�r�r%)r�r�r��replacementsrms     r?r[z&ArrowExtensionArray._replace_with_mask^s���0�l�B�O�O�4�'�6�6�8�L��f�b�o�o�.�2�8�8�3F�3F�v�{�{�3S��*�*�,�F�	��'�'���l�C�C���*�*�	��	���l�B�H�H�-��8�8�L��?�L�
��b�i�i�
0�'�-�-�/�L����&��/��#��t���x�x��V�[�[�d�C�Cs�?B�B,�+B,c��|jj}tjj	|�stjj|�rd}n(tjj
|�rd}nt�t�|}|j�}|j|j|��}|j�||�S)Nr]Tr�)
r�rVrTrUr�rr�r�r/rr
�numpy_dtype�construct_array_type)r�r�rr�r�r�s      r?�
_to_maskedzArrowExtensionArray._to_masked�s����>�>�&�&��
�8�8����)�R�X�X�-@�-@��-J��H�
�X�X�
 �
 ��
*��H�%�%�$�&�x�0���y�y�{���m�m�%�"3�"3�h�m�G��+�u�)�)�+�C��6�6rAc	���t|jt�rt�
|�d|||||d�|��S|j
j}tjj|�r|j�}n@tjj|�r|j�}n|j�}|jd|||||d�|��}	t|	tj�r|	St
|�j!|	d��S)N)�how�has_dropped_nar?�ngroups�idsFr��)r�r�r*r{�_groupby_opr�rVrTrUr�r�r�r�r�rr	r�)r�r�r�r?r�r�r�r�r�rmr~s          �r?r�zArrowExtensionArray._groupby_op�s�����d�j�j�+�.��7�&���-�#�����
�
��.�.�%�%��
�8�8� � ��)��+�+�-�F�
�X�X�
!�
!�'�
*��,�,�.�F��_�_�&�F�#��#�#�
��)����
��

���f�b�j�j�)��M��D�z�(�(��e�(�<�<rAc
��|jj�D��cgc],}|jd��D�cgc]}|�dn||���c}��.c}}Scc}wcc}}w)zJApply a callable to each element while maintaining the chunking structure.Fr�N)r�rr
)r��func�chunkr+s    r?�_apply_elementwisez&ArrowExtensionArray._apply_elementwise�so�����2�2�4�
�
5��!�>�>��>�?�
�?�C�����c��2�?�
�5�
�	
��
��
s�A�A�
A�Ac��|rtd|����t|�tj|j|��S)Nz!count not implemented with flags=)r�rVr:�count_substring_regexr�)r��pat�flagss   r?�
_str_countzArrowExtensionArray._str_count�s:���%�(J�E�8�&L�M�M��t�D�z�"�2�2�4�>�>�3�G�H�HrAc���|rtd|����|rtj}ntj}||j||��}t|�s|j
|�}t|�|�S)Nz$contains not implemented with flags=)�ignore_case)r�r:�match_substring_regex�match_substringr�rr�rV)r�r��caser��na�regex�pa_containsrms        r?�
_str_containsz!ArrowExtensionArray._str_contains�so���%�(M�u�h�&O�P�P���2�2�K��,�,�K��T�^�^�S�$�h�G���B�x��%�%�b�)�F��t�D�z�&�!�!rAc��t|t�r"tj|j|��}n�t|�dk(r5tjtj|j�dd�}nctj|j|d��}|ddD]7}tj|tj|j|���}�9t|�s|j|�}t|�|�S�N��patternrFr])r�r�r:�starts_withr�rrdr^rHrr�rV�r�r�r�rm�ps     r?�_str_startswithz#ArrowExtensionArray._str_startswith�s����c�3���^�^�D�N�N�C�@�F��3�x�1�}����B�J�J�t�~�~�$>��e�L���������A��G���Q�R��A��V�V�F�B�N�N�4�>�>�ST�,U�V�F�!��B�x��%�%�b�)�F��t�D�z�&�!�!rAc��t|t�r"tj|j|��}n�t|�dk(r5tjtj|j�dd�}nctj|j|d��}|ddD]7}tj|tj|j|���}�9t|�s|j|�}t|�|�Sr�)r�r�r:�	ends_withr�rrdr^rHrr�rVr�s     r?�
_str_endswithz!ArrowExtensionArray._str_endswith�s����c�3���\�\�$�.�.�#�>�F��3�x�1�}����B�J�J�t�~�~�$>��e�L�����d�n�n�c�!�f�E���Q�R��A��V�V�F�B�L�L����QR�,S�T�F�!��B�x��%�%�b�)�F��t�D�z�&�!�!rAc��t|tj�st|�s|r|rt	d��|rt
jnt
j}|dkrdn|}||j|||��}	t|�|	�S)NzRreplace is not supported with a re.Pattern, callable repl, case=False, or flags!=0r)r��replacement�max_replacements)
r��re�Pattern�callabler�r:�replace_substring_regex�replace_substringr�rV)
r�r��replr]r�r�r�r��pa_max_replacementsrms
          r?�_str_replacez ArrowExtensionArray._str_replace	s����c�2�:�:�&�(�4�.���%�*��
�
.3�r�)�)��8L�8L��'(�!�e�d�����N�N���0�	
���t�D�z�&�!�!rAc���t|t�s!tdt|�j����t|�tj|j|��S)Nz*repeat is not implemented when repeats is )r�rZr�rVrNr:r]r�)r��repeatss  r?�_str_repeatzArrowExtensionArray._str_repeat 	sR���'�3�'�%�<�T�'�]�=S�=S�<T�U��
��4��:�b�.�.�t�~�~�w�G�H�HrAc�Z�|jd�sd|��}|j||||d��S)N�^T)r�)�
startswithr��r�r�r�r�r�s     r?�
_str_matchzArrowExtensionArray._str_match(	s7���~�~�c�"��c�U�)�C��!�!�#�t�U�B�d�!�C�CrAc�x�|jd�r|jd�r|�d�}|j||||�S)N�$z\$)�endswithr�r�s     r?�_str_fullmatchz"ArrowExtensionArray._str_fullmatch/	s;���|�|�C� �C�L�L��$7��E��)�C����s�D�%��4�4rAc��|dk7r�|��tj|j||��}tj||�}tj|d�}td|�}tj||�}tj|||�}n>|dk(r%|�#|j}tj||�}ntd|�d|�d|����t|�|�S)Nr)r#r�zfind not implemented with sub=z, start=z, end=)
r:�utf8_slice_codeunitsr��find_substringr�r�rordr�rV)	r�rsr"�end�slicesrm�	not_found�start_offset�
offset_results	         r?�	_str_findzArrowExtensionArray._str_find6	s����A�:�#�/��,�,�T�^�^�U��M�F��&�&�v�s�3�F������,�I��q�%�=�L��F�F�6�<�8�M��Z�Z�	�6�=�A�F�
�a�Z�C�K��^�^�F��&�&�v�s�3�F�%�1�S�F�)�U�H�G�s�f�E��
��t�D�z�&�!�!rAc���tjj|jj�s3tjj|jj�rR|j
t�}tj|tjtj����}n|j}t	|�tj||��S�Nr\)
rTrUr�r�rVr�r�rOr��list_r�r:�binary_join)r�rbrms   r?�	_str_joinzArrowExtensionArray._str_joinG	s���
�8�8���d�n�n�1�1�2�b�h�h�6N�6N��N�N���7
��,�,�T�2�F��%�%�f�2�8�8�B�I�I�K�3H�I�F��^�^�F��t�D�z�"�.�.���5�6�6rAc�x���fd�}|j|�}t|�tj|��S)Nc�&��|j��Sr9)�	partition�r+rbs �r?r@z4ArrowExtensionArray._str_partition.<locals>.<lambda>R	s����
�
�c� 2rA�r�rVrTr��r�rb�expand�	predicaterms `   r?�_str_partitionz"ArrowExtensionArray._str_partitionQ	s4���2�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc�x���fd�}|j|�}t|�tj|��S)Nc�&��|j��Sr9)�
rpartitionr�s �r?r@z5ArrowExtensionArray._str_rpartition.<locals>.<lambda>W	s������s� 3rAr�r�s `   r?�_str_rpartitionz#ArrowExtensionArray._str_rpartitionV	s4���3�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc�v�|�d}|�d}t|�tj|j|||���S)Nrr])r"r#r$)rVr:r�r�)r�r"r#r$s    r?�
_str_slicezArrowExtensionArray._str_slice[	sD���=��E��<��D��t�D�z��#�#�D�N�N�%�d�QU�V�
�	
rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_alnumr�r4s r?�_str_isalnumz ArrowExtensionArray._str_isalnumf	�"���t�D�z�"�*�*�4�>�>�:�;�;rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_alphar�r4s r?�_str_isalphaz ArrowExtensionArray._str_isalphai	r�rAc�^�t|�tj|j��Sr9)rVr:�utf8_is_decimalr�r4s r?�_str_isdecimalz"ArrowExtensionArray._str_isdecimall	�"���t�D�z�"�,�,�T�^�^�<�=�=rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_digitr�r4s r?�_str_isdigitz ArrowExtensionArray._str_isdigito	r�rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_lowerr�r4s r?�_str_islowerz ArrowExtensionArray._str_islowerr	r�rAc�^�t|�tj|j��Sr9)rVr:�utf8_is_numericr�r4s r?�_str_isnumericz"ArrowExtensionArray._str_isnumericu	r�rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_spacer�r4s r?�_str_isspacez ArrowExtensionArray._str_isspacex	r�rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_titler�r4s r?�_str_istitlez ArrowExtensionArray._str_istitle{	r�rAc�^�t|�tj|j��Sr9)rVr:�
utf8_is_upperr�r4s r?�_str_isupperz ArrowExtensionArray._str_isupper~	r�rAc�^�t|�tj|j��Sr9)rVr:�utf8_lengthr�r4s r?�_str_lenzArrowExtensionArray._str_len�	r?rAc�^�t|�tj|j��Sr9)rVr:�
utf8_lowerr�r4s r?�
_str_lowerzArrowExtensionArray._str_lower�	� ���t�D�z�"�-�-����7�8�8rAc�^�t|�tj|j��Sr9)rVr:�
utf8_upperr�r4s r?�
_str_upperzArrowExtensionArray._str_upper�	r
rAc��|� tj|j�}n!tj|j|��}t	|�|�S�N)�
characters)r:�utf8_trim_whitespacer��	utf8_trimrV�r��to_striprms   r?�
_str_stripzArrowExtensionArray._str_strip�	sA�����,�,�T�^�^�<�F��\�\�$�.�.�X�F�F��t�D�z�&�!�!rAc��|� tj|j�}n!tj|j|��}t	|�|�Sr)r:�utf8_ltrim_whitespacer��
utf8_ltrimrVrs   r?�_str_lstripzArrowExtensionArray._str_lstrip�	�A�����-�-�d�n�n�=�F��]�]�4�>�>�h�G�F��t�D�z�&�!�!rAc��|� tj|j�}n!tj|j|��}t	|�|�Sr)r:�utf8_rtrim_whitespacer��
utf8_rtrimrVrs   r?�_str_rstripzArrowExtensionArray._str_rstrip�	rrAc�|��ts|tj|j���}tj|jt���}tj|||j�}t|�|�S�fd�}|j|�}t|�tj|��S)Nr�c�&��|j��Sr9)�removeprefix)r+�prefixs �r?r@z7ArrowExtensionArray._str_removeprefix.<locals>.<lambda>�	s���� 0� 0�� 8rA)rr:r�r�r�rrdrVr�rTr�)r�r%r��removedrmr�s `    r?�_str_removeprefixz%ArrowExtensionArray._str_removeprefix�	s����#��.�.�����H�K��-�-�d�n�n�c�&�k�J�G��Z�Z��W�d�n�n�E�F��4��:�f�%�%�8�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc�r�d�}|j|�}t|�tj|��S)Nc�"�|j�Sr9)�casefold)r+s r?r@z3ArrowExtensionArray._str_casefold.<locals>.<lambda>�	s
�����rAr�)r�r�rms   r?�
_str_casefoldz!ArrowExtensionArray._str_casefold�	s3��.�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc�|�����fd�}|j|�}t|�tj|��S)Nc�(��|j���Sr9)r�)r+�encodingr�s ��r?r@z1ArrowExtensionArray._str_encode.<locals>.<lambda>�	s����
�
�8�V� <rAr�)r�r.r�r�rms ``  r?�_str_encodezArrowExtensionArray._str_encode�	s4���<�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc��|rtd��tj|�jj	�}t|�dk(rt
d|�d���tj|j|�}|rat|t|jj��D��cic],\}}|t|�tj||g����.c}}St|�tj|dg��Scc}}w)NzOnly flags=0 is implemented.rzpat=z$ must contain a symbolic group name.)r�r��compile�
groupindex�keysrr�r:�
extract_regexr��zip�rangerV�
num_fields�struct_field)r�r�r�r��groupsrm�col�is        r?�_str_extractz ArrowExtensionArray._str_extract�	s����%�&D�E�E����C��+�+�0�0�2���v�;�!�����v�%I�J�K�K��!�!�$�.�.�#�6���"�&�%����0F�0F�*G�H��H�F�C���Z�T�$�Z������� <�=�=�H��
�
�4��:�b�o�o�f�q�c�:�;�;��s�&1Dc���tj||����fd�}|j|�}t|�t	j
|��S)N)r�c�&���j|�Sr9)�findall)r+r�s �r?r@z2ArrowExtensionArray._str_findall.<locals>.<lambda>�	s����
�
�c� 2rA)r�r1r�rVrTr�)r�r�r�r�rmr�s     @r?�_str_findallz ArrowExtensionArray._str_findall�	sD����
�
�3�e�,��2�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc��tj|j|�}tj|�}|j	�}|jtjj|��}tj|�jd�j�}t|�}t|�}tj||�j�}	|	tj|�j!|�|zz}	tj"||ztj$��}
d|
|	<|
j'||f�}
t)|�t
j*t-|
���}||j/�fS)Nrr�T)r:�
split_patternr�rTrrrTrRr�rSr�r
r�index_inrr\�repeatrQr�r�rVr�rO�	to_pylist)r�rbr��flattened_valuesr��uniques_sorted�lengths�n_rows�n_colsr��dummiesrms            r?�_str_get_dummiesz$ArrowExtensionArray._str_get_dummies�	s+��� � �����5���?�?�5�1��"�)�)�+�� ���b�j�j�&C�&C�G�&L�M���&�&�u�-�7�7��:�C�C�E���T����W����+�+�.��?�H�H�J���B�I�I�f�-�4�4�W�=��F�F���(�(�6�F�?�"�(�(�;�������/�/�6�6�"2�3����d��B�H�H�T�'�]�3�4���~�/�/�1�1�1rAc��������fd�}|j|�}t|�tj|��S)Nc�*��|j����Sr9)r��r+r�r"rss ���r?r@z0ArrowExtensionArray._str_index.<locals>.<lambda>�	�����	�	�#�u�c� :rAr��r�rsr"r�r�rms ```  r?�
_str_indexzArrowExtensionArray._str_index�	�4���:�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc��������fd�}|j|�}t|�tj|��S)Nc�*��|j����Sr9)�rindexrOs ���r?r@z1ArrowExtensionArray._str_rindex.<locals>.<lambda>�	s����
�
�3��s� ;rAr�rQs ```  r?�_str_rindexzArrowExtensionArray._str_rindex�	s4���;�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc�x���fd�}|j|�}t|�tj|��S)Nc�0��tj�|�Sr9)�unicodedata�	normalize)r+�forms �r?r@z4ArrowExtensionArray._str_normalize.<locals>.<lambda>�	s���� 5� 5�d�C� @rAr�)r�r\r�rms `  r?�_str_normalizez"ArrowExtensionArray._str_normalize�	s4���@�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc��������fd�}|j|�}t|�tj|��S)Nc�*��|j����Sr9)�rfindrOs ���r?r@z0ArrowExtensionArray._str_rfind.<locals>.<lambda>�	rPrAr�rQs ```  r?�
_str_rfindzArrowExtensionArray._str_rfind�	rSrAc��|dvrd}|�tj}nM|r&tjtj|��}n%tjtj
|��}t
|�||j|���S)N�rr�r�)�
max_splits)r:�utf8_split_whitespace�	functools�partial�split_pattern_regexrBrVr�)r�r�r]r�r��
split_funcs      r?�
_str_splitzArrowExtensionArray._str_split�	so��
��<��A��;��1�1�J�
�"�*�*�2�+A�+A�3�O�J�"�*�*�2�+;�+;�S�I�J��t�D�z�*�T�^�^��B�C�CrAc���|dvrd}|�1t|�tj|j|d���St|�tj|j||d���S)NrcT)rd�reverse)rVr:rer�rB)r�r�r]s   r?�_str_rsplitzArrowExtensionArray._str_rsplit�	si����<��A��;��4��:��(�(����A�t�T��
��4��:�� � ������D�Q��
rAc�x���fd�}|j|�}t|�tj|��S)Nc�&��|j��Sr9)�	translate)r+�tables �r?r@z4ArrowExtensionArray._str_translate.<locals>.<lambda>

s����
�
�e� 4rAr�)r�rqr�rms `  r?�_str_translatez"ArrowExtensionArray._str_translate	
s4���4�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc���||d<tjdi|����fd�}|j|�}t|�t	j
|��S)N�widthc�D��dj�j|��S)N�
)�join�wrap)r+�tws �r?r@z/ArrowExtensionArray._str_wrap.<locals>.<lambda>
s����	�	�"�'�'�#�,� 7rAr�)�textwrap�TextWrapperr�rVrTr�)r�rtr�r�rmrys     @r?�	_str_wrapzArrowExtensionArray._str_wrap
sP�����w��
�
!�
!�
+�F�
+��7�	��(�(��3���t�D�z�"�*�*�6�2�3�3rAc��t|�tj|j�jdtj
����S�NT)r�rV)rVrTr�r��daysrr4s r?�_dt_dayszArrowExtensionArray._dt_days
s:���t�D�z��H�H�T�,�,�.�3�3��B�H�H�J�W�
�	
rAc	���t|�tj|j�D�cgc]"}|tur|j
jnd��$c}tj����Scc}wr�)rVrTr�r�r
�
components�hoursr�r��tds  r?�	_dt_hourszArrowExtensionArray._dt_hours
sl���t�D�z��H�H�#�5�5�7��7��,.�S�=�B�M�M�'�'�d�B�7���X�X�Z�
�
�	
����'A3c	���t|�tj|j�D�cgc]"}|tur|j
jnd��$c}tj����Scc}wr�)rVrTr�r�r
r��minutesrr�s  r?�_dt_minuteszArrowExtensionArray._dt_minutes'
sl���t�D�z��H�H�#�5�5�7��7��.0�s�]�B�M�M�)�)��D�7���X�X�Z�
�
�	
��r�c��t|�tj|j�jdtj
����Sr~)rVrTr�r��secondsrr4s r?�_dt_secondszArrowExtensionArray._dt_seconds3
s=���t�D�z��H�H��'�'�)�1�1�t�"�(�(�*�
�
�	
rAc	���t|�tj|j�D�cgc]"}|tur|j
jnd��$c}tj����Scc}wr�)rVrTr�r�r
r��millisecondsrr�s  r?�_dt_millisecondsz$ArrowExtensionArray._dt_milliseconds;
sl���t�D�z��H�H�#�5�5�7��7��35�C�-�B�M�M�.�.�T�I�7���X�X�Z�
�
�	
��r�c��t|�tj|j�jdtj
����Sr~)rVrTr�r��microsecondsrr4s r?�_dt_microsecondsz$ArrowExtensionArray._dt_microsecondsG
s?���t�D�z��H�H��'�'�)�6�6� ��X�X�Z�
�
�	
rAc��t|�tj|j�jdtj
����Sr~)rVrTr�r��nanosecondsrr4s r?�_dt_nanosecondsz#ArrowExtensionArray._dt_nanosecondsQ
s=���t�D�z��H�H��'�'�)�5�5�4�b�h�h�j�
�
�	
rAc��|jj�}|jjjdk(r!|D�cgc]}|�dn|j���}}t
j|t��Scc}w)Nr�r�)	r�rEr�r�r��to_pytimedeltarr�r��r�rI�tss   r?�_dt_to_pytimedeltaz&ArrowExtensionArray._dt_to_pytimedeltaY
si���~�~�'�'�)���;�;�$�$�)�)�T�1�JN�O�$�B�B�J�D�B�,=�,=�,?�?�$�D�O��x�x��F�+�+��Ps�A:c��t|�tj|j�j	�d���S)NTr)rVrTr�r��
total_secondsr4s r?�_dt_total_secondsz%ArrowExtensionArray._dt_total_seconds_
s5���t�D�z��H�H�T�,�,�.�<�<�>�D�Q�
�	
rAc��tjj|jj�rtd��|j
�}t|�tj|j|�d���S)Nz&as_unit not implemented for date typesTr)
rTrUr�r�r�r�r�rVr�r)r�r��pd_arrays   r?�_dt_as_unitzArrowExtensionArray._dt_as_unitd
s_��
�8�8���D�J�J�4�4�5�%�&N�O�O��5�5�7���t�D�z�"�(�(�8�#3�#3�D�#9�t�L�M�MrAc�^�t|�tj|j��Sr9)rVr:�yearr�r4s r?�_dt_yearzArrowExtensionArray._dt_yeark
� ���t�D�z�"�'�'�$�.�.�1�2�2rAc�^�t|�tj|j��Sr9)rVr:�dayr�r4s r?�_dt_dayzArrowExtensionArray._dt_dayo
s ���t�D�z�"�&�&����0�1�1rAc�^�t|�tj|j��Sr9)rVr:�day_of_weekr�r4s r?�_dt_day_of_weekz#ArrowExtensionArray._dt_day_of_weeks
� ���t�D�z�"�.�.����8�9�9rAc�^�t|�tj|j��Sr9)rVr:�day_of_yearr�r4s r?�_dt_day_of_yearz#ArrowExtensionArray._dt_day_of_yearz
r�rAc�^�t|�tj|j��Sr9)rVr:�hourr�r4s r?�_dt_hourzArrowExtensionArray._dt_hour�
r�rAc�^�t|�tj|j��Sr9)rVr:�iso_calendarr�r4s r?�_dt_isocalendarz#ArrowExtensionArray._dt_isocalendar�
s ���t�D�z�"�/�/�$�.�.�9�:�:rAc�^�t|�tj|j��Sr9)rVr:�is_leap_yearr�r4s r?�_dt_is_leap_yearz$ArrowExtensionArray._dt_is_leap_year�
s ���t�D�z�"�/�/�$�.�.�9�:�:rAc��t|�tjtj|j�d��S�Nr])rVr:r�r�r�r4s r?�_dt_is_month_startz&ArrowExtensionArray._dt_is_month_start�
s+���t�D�z�"�(�(�2�6�6�$�.�.�#9�1�=�>�>rAc	���tjtjtj|jd��tj
|jd���d�}t
|�|�S)Nr�r�monthr]�r:r��days_between�floor_temporalr��
ceil_temporalrV�r�rms  r?�_dt_is_month_endz$ArrowExtensionArray._dt_is_month_end�
s\������O�O��!�!�$�.�.�u�=�� � ����g�>�
�
�
���t�D�z�&�!�!rAc
��t|�tjtjtj|j
�d�tjtj|j
�d���Sr��rVr:rFr�r�r�r�r4s r?�_dt_is_year_startz%ArrowExtensionArray._dt_is_year_start�
sW���t�D�z��G�G�������$�.�.�1�1�5����������/��3�
�
�	
rAc
��t|�tjtjtj|j
�d�tjtj|j
�d���S)N��r�r4s r?�_dt_is_year_endz#ArrowExtensionArray._dt_is_year_end�
sW���t�D�z��G�G�������$�.�.�1�2�6����������/��4�
�
�	
rAc���tjtj|jd��tj|jd���}t	|�|�S)N�quarterrr�)r:r�r�r�rVr�s  r?�_dt_is_quarter_startz(ArrowExtensionArray._dt_is_quarter_start�
sK��������d�n�n�9�=����d�n�n�5�9�
���t�D�z�&�!�!rAc	���tjtjtj|jd��tj
|jd���d�}t
|�|�S)Nr�rr�r]r�r�s  r?�_dt_is_quarter_endz&ArrowExtensionArray._dt_is_quarter_end�
s\������O�O��!�!�$�.�.�u�=�� � ����i�@�
�
�
���t�D�z�&�!�!rAc���tjtj|jd��tj|jd���}t|�|�S)Nr�r)r:r�r�r�r�rVr�s  r?�_dt_days_in_monthz%ArrowExtensionArray._dt_days_in_month�
sK��������d�n�n�7�;����T�^�^�'�:�
���t�D�z�&�!�!rAc�^�t|�tj|j��Sr9)rVr:�microsecondr�r4s r?�_dt_microsecondz#ArrowExtensionArray._dt_microsecond�
r�rAc�^�t|�tj|j��Sr9)rVr:�minuter�r4s r?�
_dt_minutezArrowExtensionArray._dt_minute�
� ���t�D�z�"�)�)�D�N�N�3�4�4rAc�^�t|�tj|j��Sr9)rVr:r�r�r4s r?�	_dt_monthzArrowExtensionArray._dt_month�
s ���t�D�z�"�(�(�4�>�>�2�3�3rAc�^�t|�tj|j��Sr9)rVr:�
nanosecondr�r4s r?�_dt_nanosecondz"ArrowExtensionArray._dt_nanosecond�
s ���t�D�z�"�-�-����7�8�8rAc�^�t|�tj|j��Sr9)rVr:r�r�r4s r?�_dt_quarterzArrowExtensionArray._dt_quarter�
s ���t�D�z�"�*�*�T�^�^�4�5�5rAc�^�t|�tj|j��Sr9)rVr:�secondr�r4s r?�
_dt_secondzArrowExtensionArray._dt_second�
r�rAc�z�t|�|jjtj���Sr9)rVr�rrT�date32r4s r?�_dt_datezArrowExtensionArray._dt_date�
s(���t�D�z�$�.�.�-�-�b�i�i�k�:�;�;rAc��|jjjdvr |jjjnd}t|�|jjt
j|���S)N>r�r�r�)r�r�r�rVr�rrT�time64)r�r�s  r?�_dt_timezArrowExtensionArray._dt_time�
sc���z�z�'�'�,�,��<�
�J�J�$�$�)�)��	
�
�t�D�z�$�.�.�-�-�b�i�i��o�>�?�?rAc�h�tj|jjj�Sr9)r
�maybe_get_tzr�r�r�r4s r?�_dt_tzzArrowExtensionArray._dt_tz�
s#���%�%�d�j�j�&>�&>�&A�&A�B�BrAc�B�|jjjSr9)r�r�r�r4s r?�_dt_unitzArrowExtensionArray._dt_unit�
s���z�z�'�'�,�,�,rAc�b�t|�tj|jdd��S)Nr]r�)rVr:r�r�r4s r?�
_dt_normalizez!ArrowExtensionArray._dt_normalize�
s&���t�D�z�"�+�+�D�N�N�A�u�E�F�FrAc�b�t|�tj|j|���S)N)�format�rVr:�strftimer�)r�r�s  r?�_dt_strftimez ArrowExtensionArray._dt_strftime�
s"���t�D�z�"�+�+�d�n�n�V�D�E�ErAc�z�|dk7rtd��|dk7rtd��t|�}|�td|����dddddddd	d
ddd
ddd�}|j|jd�}|�td|�d���|j
}t
t|�d��}	t|�|	|j||���S)Nr�zambiguous is not supported.znonexistent is not supported.z Must specify a valid frequency: r�r�r��weekr�r�r�r��millisecondr�r�)�Y�YS�Q�QS�M�MS�W�D�hr�r�r�r�r�zfreq=� is not supported�	_temporal)�multipler�)
r�r0r�r��_prefixr]rPr:rVr�)
r�r��freq�	ambiguous�nonexistent�offset�pa_supported_unitr�r�rounding_methods
          r?�_round_temporallyz%ArrowExtensionArray._round_temporally�
s������%�&C�D�D��'�!�%�&E�F�F��4����>��?��v�F�G�G���������������
�� !�$�$�V�^�^�T�:���<����w�&7�8�9�9��8�8��!�"���	�&:�;���t�D�z�/�$�.�.�8�RV�W�X�XrAc�*�|jd|||�S)N�ceil�r�r�rrrs    r?�_dt_ceilzArrowExtensionArray._dt_ceil!s���%�%�f�d�I�{�K�KrAc�*�|jd|||�S)Nrgrrs    r?�	_dt_floorzArrowExtensionArray._dt_floor)����%�%�g�t�Y��L�LrAc�*�|jd|||�S)Nr�rrs    r?�	_dt_roundzArrowExtensionArray._dt_round1rrAc�l�|�d}t|�tj|jd|���S)N�Cz%A�r��localer��r�rs  r?�_dt_day_namez ArrowExtensionArray._dt_day_name9�.���>��F��t�D�z�"�+�+�d�n�n�T�&�Q�R�RrAc�l�|�d}t|�tj|jd|���S)Nrz%Brr�rs  r?�_dt_month_namez"ArrowExtensionArray._dt_month_name>rrAc��tjj|jj�r#td|jj�d���|jj�}|jjjdk(r#|D�cgc]}|�dn|jd����}}tj|t��Scc}w)Nz$to_pydatetime cannot be called with z) type. Convert to pyarrow timestamp type.r�F)�warnr�)rTrUr�r�r�r�r�rEr�r��
to_pydatetimerr�r�r�s   r?�_dt_to_pydatetimez%ArrowExtensionArray._dt_to_pydatetimeCs���
�8�8���D�J�J�4�4�5��6�t�z�z�7O�7O�6P�Q5�5��
��~�~�'�'�)���;�;�$�$�)�)�T�1�SW�X�SW�R�B�J�D�B�,<�,<�%�,<�,H�H�SW�D�X��x�x��F�+�+��Ys�Cc��|dk7rtd|�d���dddd�j|d�}|�td|�d���|�M|jjt	j
|jjj��}n,tj|jt|�||��}t|�|�S)	Nr�z
ambiguous=r�earliest�latest)r��shift_backward�
shift_forwardznonexistent=)rr)
r�r�r�rrTr�r�r�r�r:�assume_timezoner�rV)r�r�rr�nonexistent_parms      r?�_dt_tz_localizez#ArrowExtensionArray._dt_tz_localizeNs������%����4E�&F�G�G��(�%�
��#���
�		��!�%����6G�&H�I�I�
�:��^�^�(�(����d�j�j�6N�6N�6S�6S�)T�U�F��'�'�����B��9�.��F��t�D�z�&�!�!rAc��|jjj�td��|jjj}|j
j
tj||��}t|�|�S)Nz?Cannot convert tz-naive timestamps, use tz_localize to localize)
r�r�r�r2r�r�rrTr�rV)r�r��current_unitrms    r?�_dt_tz_convertz"ArrowExtensionArray._dt_tz_convertgso���:�:�#�#�&�&�.��Q��
��z�z�/�/�4�4�����$�$�R�\�\�,��%C�D���t�D�z�&�!�!rA)r��pa.Array | pa.ChunkedArrayr��None)r�zDtype | Noner�rLr9)r��pa.DataType | Noner�z&pa.Array | pa.ChunkedArray | pa.Scalar)r�r0r��	pa.Scalarro)r�r0r�rLr�r.)r&r�)r�z
Iterator[Any])NN)r�zNpDtype | Noner��bool | Noner��
np.ndarray)r�r�)r�r/)r�rL)r�r1)r�rZ)r��npt.NDArray[np.bool_])r�rL)r�rLrr�r�r�r�r3)r�rLr�r�r�rZ)T)r�rLr�rZ)
r�r�r��
int | Noner�z#Literal['inside', 'outside'] | Noner�rLr�r�)NNNT)
r�zobject | ArrayLike | Noner�zFillnaOptions | Noner�r5r�rLr�r�)r�r�r�r4)r�ztuple[np.ndarray, Any])r�rLr�z!tuple[np.ndarray, ExtensionArray])r)r�rZr�r�)rhN)r�z$NumpyValueArrayLike | ExtensionArrayr�zLiteral['left', 'right']r�zNumpySorter | Noner�znpt.NDArray[np.intp] | np.intp)FN)r�r�r�rLr�rr�r�)r�r�)r�r�)r�r3)r�znpt.DTypeLike | Noner�rLrr�r�r3)r�)rzLiteral['first', 'last', False]r�r4)r�rLr�r�)rr�r�rLr�z$ArrowExtensionArray | ExtensionArray)rr�r�rLr�r1)rr�r�rLrKrL)
rar�r�r�rbr�r�rLrcrL)rvznpt.NDArray[np.float64]rur�r�r�)r�rLr�r�)r�r�rarZr�rLr�r�)r��npt.NDArray[np.bool_] | boolrh�ArrayLike | Scalarrir7)r�r.r�r6r�r7)
r�r�r�rLr?rZr�rZr�znpt.NDArray[np.intp])r�rr�zlist[list[Any]])r�r�r�rZ)TrNT)r�rLr�rZr�rL)r�zstr | tuple[str, ...])r�TrT)r�zstr | re.Patternr�zstr | Callabler]rZr�rLr�rZr�rL)r�zint | Sequence[int])TrN)r�r�r�rLr�rZr��
Scalar | None)r�rLr�rZr�r8)rN)rsr�r"rZr�r5)rbr�)rbr�r�rL)NNN)r"r5r#r5r$r5)r%r�)�strict)r.r�r�r�)rT)r�r�r�rZr�rL)�|)r\r�)rsr�r"rZ)Nr�FN)r��
str | Noner]r5r�rLr�r2)Nr�)r�r;r]r5)rqzdict[int, str])rtrZ)r�r�)r�r�)r�r�)r�z!Literal['ceil', 'floor', 'round']rr�rr�)rr�rr�)rr;)�rN�
__module__�__qualname__�__doc__�__annotations__r��classmethodr�r�r�r�r�r'r,rr/r5r8r;r>rDrJrXrfrjrmrp�propertyr�rsrur|r�rryr�r�r�r�r�r�r�r�rr'rr�r�r�r�r�r�rr�r�r�r�r
r	r�rr
rrr r*rIr�rMrQr^rrrjrwr|rVr�rYr[r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rrrr	rrrrr!r'r+r/r<r@rLrRrWr]rarjrmrrr|r�r�r�r�r�r�r�r�r�r�r�r�r��
_dt_dayofweek�_dt_weekdayr��
_dt_dayofyearr�r�r�r�r�r�r�r�r�r��_dt_daysinmonthr�r�r�r�r�r�r�r�r�r�r�r�rrrrrrr"r*r-�
__classcell__)r~s@r?r�r��s����)�V����6��>B�QV�����/3�%�GE� ,�GE�;?�GE��GE�R�26�1�/�1�	/�1��1�&�%��%�N�EJ�^�/�^�>B�^�	#�^��^�@Y�v�(�
AE�*�#�*�2=�*�	�*�
9�=�*�:�
�
$�+�41"�fL�K�1������%��%�#�
/��-��-�
3�%)�8<�t%)�8<�z�$�!�5��5��	5�
�5�
�5�&-� /�/�
*�8�!�:>��

��
��	
�
8�
��

�
�
�@	��	�	��,0�'+� ��+R�(�+R�%�+R��	+R�
�+R�
�
+R� �+R�Z0�+�"	��	!�	!�"�!%�  ��  �
+�  �#�  �D
�F�0	��	$�	$�%�*0�%)�	X�3�X�'�X�#�	X�

(�X�&�X�8!��	ZB��ZB��ZB��	ZB�

�ZB�x�
@�	D�*�
	��	 �	 �!�'+���>�>�	8�#�8��8��	8�

�8�"�8�t2�	��	"�	"�#�6=�>�3�>�	�>�$�>�.%�.-E�^����,,0�;"��;"�$(�;"�	-�;"�z<@�~�B,0�%����$(��;?��B,0�%����$(��;?��,�,M�d�����>��>��	>�
�>��
>��>�F�����
��
��	
�
�
��

��
�,%"�N('�T�%I�#�%I��	%I��%I�
�%I�N�)@�*�)@�!�)@�"�	)@��)@�V�(D�*�(D�+�(D�)�	(D��(D�Z
7�(=��(=��	(=�
�(=��
(=�"�(=�T
�I�NR�
"��
"�-0�
"�FJ�
"�"�""�*����"�
�"��"��	"�
�"��
"��"�6I�PT�D��D�"�D�25�D�?L�D�KO�5��5�-0�5�:G�5�"�"7�4�
4�UY�	
��	
�.8�	
�GQ�	
�<�<�>�<�<�>�<�<�<�:�9�9�"�"�"�4�4�
4�

<�4�2� 4�
4�
4�
4����!�D�
�D��D��	D�
�D�"
�4�
4��
��
�
�	
��	
��	
��	
��
��
��	
��	
��
��
��
��
�,�
�
N��3��3��2��2��:��:�$�M�!�K�
�:��:�$�M�
�3��3�;��;��;��?��?��"��"��
��
��
��
��"��"��"��"��"��"�(�O�
�:��:��5��5��4��4��9��9��6��6��5��5��<��<��@��@��C��C��-��-�G�F�$+�'.�#Y�1�#Y�!�	#Y�
%�#Y�P$+�'.�	L�!�L�%�	L�$+�'.�	M�!�M�%�	M�$+�'.�	M�!�M�%�	M�S�
S�
	,�$+�'.�	"�!�"�%�	"�2"rAr�c	���t|�}t|d�t|�}}tj||z�j	||�j
j
�}tj|D��cgc]}|jjD]}|���!c}}�}|j|�}t|�D�cgc] }t|j||z|����"c}Scc}}wcc}w)z�Transpose arrow extension arrays in a list, but faster.

    Input should be a list of arrays of equal length and all have the same
    dtype. The caller is responsible for ensuring validity of input data.
    r)rOrrr\r��T�flattenrTr�r�rrr6r�r!)�arrays�nrows�ncolsr�r�r�r;s       r?�transpose_homogeneous_pyarrowrMqs����&�\�F��v�a�y�>�3�v�;�5�E��i�i���
�&�.�.�u�e�<�>�>�F�F�H�G�
�
�
�V�V�V�c����AU�AU��E�AU�E�V�V�
W�C�

�(�(�7�
�C�FK�E�l�S�l����	�	�!�e�)�U� ;�<�l�S�S��W��Ss�9$C+
�%C1)rXr�rYzpa.Array | pa.Scalarr�z,tuple[pa.ChunkedArray, pa.Array | pa.Scalar])rh�&pa.ChunkedArray | pa.Array | pa.ScalarrirNr�r�)r�z'ArrowDtype | pa.DataType | Dtype | Noner�r0)rJzSequence[ArrowExtensionArray]r�zlist[ArrowExtensionArray])��
__future__rrfr[r�rz�typingrrrrrrZ�numpyr�pandas._libsr	�pandas._libs.tslibsr
rrr
�
pandas.compatrrr�pandas.util._decoratorsr�pandas.util._validatorsr�pandas.core.dtypes.castrr�pandas.core.dtypes.commonrrrrrrrr�pandas.core.dtypes.dtypesr�pandas.core.dtypes.missingr�pandas.corerrr r!r"�pandas.core.algorithmsr#�pandas.core.arrayliker$�'pandas.core.arrays._arrow_string_mixinsr%�pandas.core.arrays._utilsr&�pandas.core.arrays.baser'r(�pandas.core.arrays.maskedr)�pandas.core.arrays.string_r*�pandas.core.common�core�commonrW�pandas.core.indexersr+r,r-�pandas.core.strings.baser.�pandas.io._utilr/�pandas.tseries.frequenciesr0rrT�pyarrow.computerRr:r1r�r`rb�greater�
less_equal�
greater_equalrMr;rCrEr_rLrNrQrhrZrnrrrvr{r`r�rl�collections.abcr��pandas._typingr�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�rr�r�r�r�r�r�r�r�rMr�rAr?�<module>rps���"���	�����������
(�:��	�	�	�6�+���-�*�I�>��6�2� � ���
<�0�0��� �4��h�h��l�l��g�g��j�j��m�m����
�O��
�
�1��|�|�/��v�v�)�
�����3��~�~�1����2�
��&�$�&�1E�&�	5�&� �4��5��
��@�
�r�~�~���1��	�r�"�"��	�6�	�
	�r�"�"��	�6�
�	�B��	�C��	�6��	�7��	�~��	���	�.��	�>��	�r���� 	�3�!��&�(������(�:�<���2����,A*"�� ���	A*"�HT
T�)�
T��
TrA

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