
     j                      d dl mZ d dlZd dlZd dlZd dlZd dlmZmZm	Z	m
Z
mZ d dlZd dlZd dlmZ d dlmZmZmZmZ d dlmZmZmZ d dlmZ d dlmZ d d	lmZm Z  d d
l!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z) d dl*m+Z+ d dl,m-Z- d dl.m/Z0m1Z1m2Z2m3Z3 d dl4m5Z5 d dl6m7Z7 d dl8m9Z9 d dl:m;Z; d dl<m=Z=m>Z> d dl?m@Z@ d dlAmBZB d dlCmDc mEZF d dlGmHZHmIZImJZJ d dlKmLZL d dlMmNZN d dlOmPZP esd dlQZRd dlSmTZU d dl*mVZV eUjW        eUjX        eUjY        eUjZ        eUj[        eUj\        dZ]eUj^        d eUj_        d eUj`        d dZaeUjb        d eUjc        d  eUjd        d! dZedUd(ZfdVd,Zgi d-eUjh        d.d/ d0eUji        d1d2 d3eUjj        d4d5 d6d7 d8d9 d:d; d<d= d>ekd?ekd@ekdAekdBeUjl        dCdD Zmer>d dElnmoZo d dFlpmqZqmrZrmsZsmtZtmuZumvZvmwZwmxZxmyZymzZzm{Z{m|Z|m}Z}m~Z~mZmZmZ d dGlmZ d dHlmZ d dIlmZ dJ ZdWdNZ G dO dPe7e>e9eL          ZdXdTZdS )Y    )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                ,    t          j        ||           S N)pc
and_kleenexys     rC:\Users\Terasoftware\OneDrive\Desktop\faahhh\fyndo\fyndo\venv\Lib\site-packages\pandas/core/arrays/arrow/array.py<lambda>r@   ^   s    bmAq11     c                ,    t          j        ||           S r9   )r:   	or_kleener<   s     r?   r@   r@   `   s    R\!Q// rA   c                ,    t          j        ||           S r9   )r:   xorr<   s     r?   r@   r@   b   s    RVAq\\ rA   )and_rand_or_ror_rE   rxorc                ,    t          j        ||           S r9   )r:   bit_wise_andr<   s     r?   r@   r@   g   s    boa33 rA   c                ,    t          j        ||           S r9   )r:   bit_wise_orr<   s     r?   r@   r@   i       R^Aq11 rA   c                ,    t          j        ||           S r9   )r:   bit_wise_xorr<   s     r?   r@   r@   k   s    R_Q22 rA   arrow_arraypa.ChunkedArray	pa_objectpa.Array | pa.Scalarreturn,tuple[pa.ChunkedArray, pa.Array | pa.Scalar]c                :   t           j                            | j                  rtt           j                            |j                  rPt	          j        | t          j                    d          t	          j        |t          j                    d          fS | |fS )NF)safe)patypesr   typer:   r   float64)rR   rT   s     r?   cast_for_truedivr^   n   s    
 8{/00 	RX5H5HN6
 6
 	
 7;
5AAA272:<<eD D D   I%%rA   left&pa.ChunkedArray | pa.Array | pa.Scalarrightc           
        t           j                            | j                  r:t           j                            |j                  rt	          j        | |          }t           j                            |j                  rt	          j        t	          j        ||          |           }t	          j	        t	          j
        | |          t          j        d|j                            }t	          j        t	          j        ||          t	          j        |t          j        d|j                            |          }n|}|                    | j                  }n)t	          j        | |          }t	          j        |          }|S )Nr   r\      )rZ   r[   r   r\   r:   divide_checkedis_signed_integer	not_equalmultiplylessrQ   scalarif_elserF   subtractr   dividefloor)r_   ra   dividedhas_remainderhas_one_negative_operandresults         r?   floordiv_compatrs   ~   sE    8ty)) 	'bh.A.A%*.M.M 	''e44Gx))',77 ! "R[%-H-H$ O O+-7OD%00Iagl333, ,( G%0 
 K17<)H)H)HII  ![[++FFie,,GXg&&FrA   addraddc                ,    t          j        ||           S r9   )r:   add_checkedr<   s     r?   r@   r@      rO   rA   subrsubc                ,    t          j        ||           S r9   )r:   subtract_checkedr<   s     r?   r@   r@          R0A66 rA   mulrmulc                ,    t          j        ||           S r9   )r:   multiply_checkedr<   s     r?   r@   r@      r|   rA   truedivc                :    t          j        t          | |           S r9   r:   rm   r^   r<   s     r?   r@   r@      s    	+;Aq+A+A B rA   rtruedivc                :    t          j        t          ||            S r9   r   r<   s     r?   r@   r@      s    ,<Q,B,B!C rA   floordivc                "    t          | |          S r9   rs   r<   s     r?   r@   r@      s    A!6!6 rA   	rfloordivc                "    t          ||           S r9   r   r<   s     r?   r@   r@      s    /!Q"7"7 rA   modrmoddivmodrdivmodpowrpowc                ,    t          j        ||           S r9   )r:   power_checkedr<   s     r?   r@   r@      s    R-a33 rA   )Sequence)	ArrayLikeAxisIntDtypeFillnaOptionsInterpolateOptionsIteratorNpDtypeNumpySorterNumpyValueArrayLikePositionalIndexerScalarSelfSortKindTakeIndexerTimeAmbiguousTimeNonexistentnpt)Series)DatetimeArrayTimedeltaArrayc                    t           rFt          |                               dd          d         d d         }|dvrt          |           |S | j        S )N[rd   )smsusns)r   strsplit
ValueErrorunit)pa_dtyper   s     r?   get_unit_from_pa_dtyper      s\     8}}""3**2.ss3.. 	'X&&&=rA   dtype'ArrowDtype | pa.DataType | Dtype | Nonepa.DataType | Nonec                6   t          | t                    r| j        S t          | t          j                  r| S t          | t
                    rt          j        | j        | j                  S | r*	 t          j	        |           S # t          j
        $ r Y nw xY wdS )z3
    Convert dtype to a pyarrow type instance.
    N)
isinstancer1   pyarrow_dtyperZ   DataTyper   	timestampr   tzfrom_numpy_dtypeArrowNotImplementedErrorr   s    r?   to_pyarrow_typer      s     %$$ ""	E2;	'	' 
	E?	+	+ |EJ111	 	 &u---* 	 	 	D	4s   0B BBc                  
    e Zd ZU dZded<   ded<   d2d
Zedddd3d            Zedddd3d            Ze	 d4d5d            Z	ed4d6d            Z
e	 d7d8d            Zd9dZd:dZd4d Z	 d;d<d$Zd=d&Zd=d'Zd=d(Zd=d)Zd* Zd>d+Zd, Zd- Zd. Zd/ Zd?d0Zed@d1            ZedAd3            ZdAd4Zd? fd5Zed?d6            Z dBd8Z!d9d:dCd<Z"d9d:dCd=Z#d9d>d?d@dDdFZ$dE fdHZ%dFdGdIZ&dFdGdJZ'd=dKZ(d=dLZ)ddd9dMdH fdSZ* e+e,j-                  	 	 	 	 dIdJ fdW            Z-dKdYZ.dLd[Z/ e+e,j0                  	 dFdMd^            Z0d_ Z1dNdOdbZ2 e+e,j3                  	 	 dPdQdj            Z3	 	 dRdSdpZ4dq Z5dTdsZ6dUduZ7dV fdvZ8 e+e,j9                  dde:j;        fdWdz            Z9d4 fd{	Z< e+e,j=                  	 dXdYd            Z=d=dZ>dFdZdZ?ed=d            Z@d9d:d[ fdZAd9d:d\ fdZBd9ddd]dZCd9ddd]dZD fdZEd>dZFd`dd}d9ddd^ fdZGd`dd}d9ddd^dZHd_dZIdFd`dZJd ZKdadZLedbd            ZMedcd            ZNd ZOdd fdZPdedZQdNdfdZR	 dgdhdZSd4didZTd4didZU	 	 	 	 djdkdZVdldĄZW	 dmdndǄZX	 dmdodȄZYdpdqd̄ZZdrd΄Z[dsdЄZ\dsdфZ]	 dtdudԄZ^dՄ Z_dք Z`dׄ Zad؄ Zbdل Zcdڄ Zddۄ Zed܄ Zfd݄ Zgdބ Zhd߄ Zid Zjd4dZkd4dZld4dZmdvdZnd ZodwdxdZpdydzdZqdNdfdZrd{drdZsdpdqdZtdpdqdZud|dZvdpd}dZw	 	 	 	 d~ddZxdddZyddZzddZ{ed             Z|ed             Z}ed             Z~ed             Zed              Zed             Zed             Zd Zd ZddZed             Zed             Zed	             ZeZeZed
             ZeZed             Zd Zed             Zed             Zed             Zed             Zed             Zed             Zed             Zed             ZeZed             Zed             Zed             Zed             Zed             Zed             Zed             Zed             Zed             Zed             Zd Zdd!Z	 	 ddd(Z	 	 ddd)Z	 	 ddd*Z	 	 ddd+Zd4dd-Zd4dd.Zd/ Z	 	 ddd0Zd1 Z xZS (  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]
    rS   	_pa_arrayr1   _dtypevaluespa.Array | pa.ChunkedArrayrV   Nonec                `   t           rd}t          |          t          |t          j                  rt          j        |g          | _        nBt          |t          j                  r|| _        n t          dt          |           d          t          | j        j	                  | _        d S )NzCpyarrow>=10.0.1 is required for PyArrow backed ArrowExtensionArray.zUnsupported type 'z' for ArrowExtensionArray)r   ImportErrorr   rZ   Arraychunked_arrayr   ChunkedArrayr   r\   r1   r   )selfr   msgs      r?   __init__zArrowExtensionArray.__init__!  s     	#WCc"""fbh'' 	-vh77DNN00 	#DNNLT&\\LLL   !!455rA   NFr   copyr   Dtype | Noner   boolc               j    t          |          }|                     |||          } | |          }|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/  s=    
 "%(($$WgD$IIc(mm
rA   c                  t          |          }|]t          j                            |          s>t          j                            |          st          j                            |          r|}nt          j                            |          rddlm}  ||d          }nt          j        	                    |          rddlm}  ||d          j
        }nt          j                            |          rddlm}  ||d          }|j        dk    rt          |          }t!          |t          j        t          j        f          s(t          j        |t          j                    d	          }t+          j        |d|          }	 |                    t          j                              }n# t          j        $ r Y nw xY wnt          j                            |          rdd
lm}	  |	|d          }nmt          j                            |          rt!          |t          j        t          j        f          r|}n(t          j        |t          j                    d	          }t+          j        t+          j        |d          d|          }t+          j        t+          j        |d          d|          }|                    t          j                              }nt          j                             |          s>t          j        !                    |          st          j        "                    |          rddl#m$}
  |
|d          }ntK          d| d          | &                    |||          S )zL
        Construct a new ExtensionArray from a sequence of strings.
        Nr   )to_datetimeraise)errorsto_timedeltar   Tr\   from_pandas)to_timecoercez1.01z0.00)
to_numericzConverting strings to z is not implemented.r   )'r   rZ   r[   	is_binary	is_stringis_large_stringis_timestamppandas.core.tools.datetimesr   is_datedateis_durationpandas.core.tools.timedeltasr   r   r   r   r   r   arraystringr:   rk   r   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_strings9  s    "%((?	x!!'**?	 x!!'**?	 x''00	?	 GGX""7++ 6	??????!k'':::GGXg&& 2	??????!k'':::?GGX!!'** .	AAAAAA"l77;;;G|t#  G}}!'BHbo+FGG T hwRY[[dSSSG*T499%ll28::66GG   D Xg&& 	777777 ggh777GGX  )) 	 'BHbo#>?? P!(7$OOOj'5!9!93HHGj'5!9!93HHGll28::..GGH((	x##G,,	 x""7++	
 =<<<<< j999GG%FFFF   !!'t!DDDs   &F9 9GGr   r   &pa.Array | pa.ChunkedArray | pa.Scalarc                    t          |t          j                  st          |          s|                     ||          S |                     ||          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   rZ   r   r   _box_pa_scalarr   )r   valuer   s      r?   _box_pazArrowExtensionArray._box_pa  sS      eRY'' 	6|E/B/B 	6%%eW555  000rA   	pa.Scalarc                   t          |t          j                  r|}n	t          |          rt          j        d|          }nt          |t
                    rN|t          j        |j                  }n*|j        |j        k    r|                    |j                  }|j	        }nit          |t                    rT|!t          j        |j        |j                  }n*|j        |j        k    r|                    |j                  }|j	        }t          j        ||d          }| |j        |k    r|                    |          }|S )z
        Box value into a pyarrow Scalar.

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

        Returns
        -------
        pa.Scalar
        Nrc   )r   Tr   )r   rZ   r   r   rj   r   durationr   as_unit_valuer   r   r   r\   r   )r   r  r   	pa_scalars       r?   r  z"ArrowExtensionArray._box_pa_scalar  sC    eRY'' 	III%[[ 	I	$W555II %++ % 8 k%*55GGZ7</ 8!MM',77EE9-- % 8 l5:%(CCCGGZ7</ 8!MM',77E	%g4HHHI 	09>W#< 	0!w//IrA   c                F   t          ||           r	|j        }nt          |t          j        t          j        f          r|}ntt          |t
                    r,|r|                                }|                                }n3t          |t          j	                  rU|St          j
                            |          st          j
                            |          r|                                }n%|r#t          |          r|                                }|t          j
                            |          rlt          |t          j	                  r|j        j        dvrDddlm}  |||j                                      |j                  }|                                }	 t          j        ||d          }n7# t          j        t          j        f$ r t          j        |d          }Y nw xY w|`t          j
                            |j                  r<ddlm}  ||          }|                                }t          j        ||d          }t          j
                            |j                  r<|j        dk    r1 | |          }|                    |j        j                  }|j        }||j        |k    rt          j
                            |          r|                                }n	 |                     |          }n# t          j        t          j        t          j!        f$ rh t          j
        "                    |j                  s$t          j
                            |j                  r| #                    ||	          j        cY S  w xY w|S )
z
        Box value into a pyarrow Array or ChunkedArray.

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

        Returns
        -------
        pa.Array or pa.ChunkedArray
        Nmir   r   r   Tr   r   r   )$r   r   rZ   r   r   r)   r   __arrow_array__npndarrayr[   is_large_binaryr   tolistr   r   r   kindr   r   r   r  to_numpyr   r   ArrowTypeErrorr\   
null_countfillnana_valueis_dictionarydictionary_encoder   r   r   r  )r   r  r   r   r   r   r   s          r?   r   z!ArrowExtensionArray._box_pa_array  s     eS!! 7	)HH"/:;; 5	)HH// 3	) %

,,..HH 5"*--%% H,,W55	%
 x//88%  %-.. %

 	)H((11	) $E2:66	) ;@+:JRV:V	) FEEEEE$U>>>FFw|TT((=8ETJJJOR%67 = = =8Et<<<=  K28#7#7#F#F KEEEEEE$U++((8ETJJJx##HM22 )x7JQ7N ) c(mmjj!344= 	8=G#; 	x%%g.. #5577'}}W55HHO%/   
 x))(-88 	BH<T<T = = 	
  #<<!  =    #$ $ $   s%   'F? ?1G32G3:L B
NNitemr   c                   t          | |          }t          |t          j                  rt	          |          sj| j        j        dk    r"| j        j        dv rt          j	                    }n| j        j
        } t          |           t          j        g |                    S |j        j        dv r|                     |          S |j        j        dk    r0 t          |           | j                            |                    S t%          d          t          |t&                    rt)          |          }|t*          u rt-          d          }t/          |          rt1          |          st%          d          t          |t,                    r^|j        |j        k    rnM|j        F|j        t	          |            k     r-|j        &|j        d	k     rt-          |j        d|j                  }| j        |         }t          |t          j                  r t          |           |          S | j        j        }|                                }|| j        j        S t          j                             |          r2|j!        d
k    r'tE          |          #                    |j!                  S t          j        $                    |          r2|j!        d
k    r'tK          |          #                    |j!                  S |S )a8  Select 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_numpyrc   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 indicesr   r   )&r+   r   r  r  lenr   namestoragerZ   r   r   r\   r   r   r  taker   filter
IndexErrortupler,   Ellipsisslicer   r   startstopstepr   as_pyr  r[   r   r   r   r  r   r   )r   r   r   r  r   rj   s         r?   __getitem__zArrowExtensionArray.__getitem__   s   0 #4..dBJ'' 	3t99 ;#x/ 9DK4G L 5 9  "y{{HH#{8H!tDzz""22H"E"E"EFFFD( yy&C' !tDzz$."7"7"="=>>> 8   e$$ 	3,T22D8 	;;DT?? 	:d#3#3 	 L   dE"" 
	:zTY& :	:IT
*: I: IM	: TZty99t$eR_-- 	4::e$$$n)G[[]]F 	{++&&w// GLD4H  ((00>>>%%g.. 7<43G  ((00>>>rA   Iterator[Any]c              #    K   | j         j        }| j        j        }t          j                            |          o
|j        dk    }t          j                            |          o
|j        dk    }| j        D ]y}|	                                }||V  |r*t          |                              |j                  V  I|r*t          |                              |j                  V  u|V  zdS )z5
        Iterate over elements of the array.
        r   N)r   r  r   r\   rZ   r[   r   r   r   r2  r   r  r   )r   r  r   box_timestampbox_timedeltar  vals          r?   __iter__zArrowExtensionArray.__iter__{  s       ;'.%--g66O7<4;O,,W55N',$:N^ 		 		E++--C  nn,,W\:::::: nn,,W\::::::						 		rA   c                    | j         S )z)Convert myself to a pyarrow ChunkedArray.)r   )r   r\   s     r?   r  z#ArrowExtensionArray.__arrow_array__  s
    ~rA   NpDtype | Nonebool | None
np.ndarrayc                .    |                      |          S )z?Correctly construct numpy arrays when passed to `np.asarray()`.r   r  )r   r   r   s      r?   	__array__zArrowExtensionArray.__array__  s     }}5})))rA   r   c                   t           j                            | j        j                  r/ t	          |           t          j        | j                            S t           j                            | j        j                  s)t           j                            | j        j                  rt          d           t	          |           t          j
        | j                            S )Nz-__invert__ is not supported for string dtypes)rZ   r[   r   r   r\   r:   bit_wise_notr   r   	TypeErrorinvertr   s    r?   
__invert__zArrowExtensionArray.__invert__  s    8t~233 	94::bodn==>>>X 344 	98P8PN9
 9
 	9 KLLL4::bi77888rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   negate_checkedr   rE  s    r?   __neg__zArrowExtensionArray.__neg__  s%    tDzz"+DN;;<<<rA   c                <     t          |           | j                  S r9   r\   r   rE  s    r?   __pos__zArrowExtensionArray.__pos__  s    tDzz$.)))rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   abs_checkedr   rE  s    r?   __abs__zArrowExtensionArray.__abs__  $    tDzz".88999rA   c                p    | j                                         }| j                                        |d<   |S )Nr   )__dict__r   r   combine_chunks)r   states     r?   __getstate__z ArrowExtensionArray.__getstate__  s2    ""$$!^::<<krA   c                    d|v r|                     d          }n|d         }t          j        |          |d<   | j                            |           d S )N_datar   )poprZ   r   rR  update)r   rT  datas      r?   __setstate__z ArrowExtensionArray.__setstate__  s]    e 	&99W%%DD%D-d33kU#####rA   c                   t           |j                 }t          |t          t          j        t          t          f          s$t          t          |dd           t                    r& || j
        |                     |                    }n[t          |          r%	  || j
        |                     |                    }n$# t          j        j        t          j        j        f$ r t#          |           t#          |          z  }| }t	          j        t'          |           d          }t	          j        |           }	  |||         |          ||<   n&# t*          $ r t-          j        |||          }Y nw xY wt          j        |t          j                              }t3          j        ||d           }Y n*w xY wt7          |j         dt9          |                     t          |          S )Nr   r   r   rc   z not implemented for )ARROW_CMP_FUNCS__name__r   r   r  r  listr)   getattrr   r   r  r   rZ   r	   r   r   r   zerosr&  r   rC  r!   invalid_comparisonr   r:   rk   r   r\   )r   otheroppc_funcrr   r  validnp_arrays           r?   _cmp_methodzArrowExtensionArray._cmp_method  s   !"+.'T?K
 
 	w557GHH	 WT^T\\%-@-@AAFFu 	9 e1D1DEEF3RV5HI 
9 
9 
9DzzDKK/#d))6:::8D>>I$&Bx$>$>F5MM  I I I 3HeRHHFFFI&rxzz:::E6488
9 &;BBT%[[BB   #6***s8   $C A>F< EF< E96F<8E99A F<;F<c                4   | j         j        }|                     |          }t          j                            |          s?t          j                            |          s t          j                            |          rI|t          j	        t          j        fv rt          j        d|          }|t          j	        u rt          j        | j         ||          }n)|t          j        u rt          j        || j         |          } t          |           |          S |t          j        t          j        fv r| j         }|}t          j                            |j                  st%          d          t          j        t          j        |d          d|          }	t          j        ||	          } t          |           |          S nt          j                            |j                  sHt          j                            |j                  s$t          j                            |j                  r|t          j        t          j        fv r|}| j         }t          j                            |j                  st%          d          t          j        t          j        |d          d|          }	t          j        ||	          } t          |           |          S t-          |t          j                  rIt          j        |                                          r#|j        t6          v r|                    |          }||j                 }
|
t:          u rt=          |j         d           |
| j         |          } t          |           |          S )N rc   z'Can only string multiply by an integer.r   z not implemented.)r   r\   r  rZ   r[   r   r   r   operatorrt   r"   ru   rj   r:   binary_join_element_wiser}   r~   r   rC  rk   ri   binary_repeatr   r   is_nullr2  r^  ARROW_LOGICAL_FUNCSr   NotImplementedr   )r   rc  rd  arrow_funcsr   seprr   binaryintegralpa_integralre  s              r?   _evaluate_op_methodz'ArrowExtensionArray._evaluate_op_method  s/   .%U## Hw''	&x''00	& x!!'**	&
 hlIN33 *i111% U8PSTTFF9>) U8PSTTF!tDzz&)))in55 * x**8=99 O#$MNNN j1)=)=q(KK)&+>>!tDzz&)))* Huz**	&x!!%*--	& x''
33	& X\9>22		&
 F~H8&&x}55 K IJJJ*RWXq%9%91hGGK%fk::F4::f%%%ubi((	(
5!!''))	( 22	( JJw''Ebk*n$ 	I%&G&G&GHHH//tDzz&!!!rA   c                    t           j                            | j        j                  r|                     ||t                    S |                     ||t                    S r9   )rZ   r[   r   r   r\   rv  ARROW_BIT_WISE_FUNCSro  r   rc  rd  s      r?   _logical_methodz#ArrowExtensionArray._logical_method
  sT     8t~233 	L++E27KLLL++E27JKKKrA   c                :    |                      ||t                    S r9   )rv  ARROW_ARITHMETIC_FUNCSry  s      r?   _arith_methodz!ArrowExtensionArray._arith_method  s    ''r3IJJJrA   c                P    t          |t                    sdS | j        |j        k    S NF)r   r   r   )r   rc  s     r?   equalszArrowExtensionArray.equals  s+    %!455 	5 ~00rA   c                    | j         S )z2
        An instance of 'ExtensionDtype'.
        )r   rE  s    r?   r   zArrowExtensionArray.dtype  s    
 {rA   intc                    | j         j        S )zL
        The number of bytes needed to store this object in memory.
        )r   nbytesrE  s    r?   r  zArrowExtensionArray.nbytes#  s    
 ~$$rA   c                *    t          | j                  S )z]
        Length of this array.

        Returns
        -------
        length : int
        )r&  r   rE  s    r?   __len__zArrowExtensionArray.__len__*  s     4>"""rA   c                `   t          |          rq|| j        j        urc| j        j        dk    rQt	          j        |          r=t          j        t          j        | j	                            
                                S dS t          t                                          |                    S )NfF)r   r   r  r  r	   is_floatr:   anyis_nanr   r2  r   super__contains__)r   key	__class__s     r?   r  z ArrowExtensionArray.__contains__4  s    99 	DJ$77 	z#% A#,s*;*; Avbi7788>>@@@ 5 EGG((--...rA   c                "    | j         j        dk    S )Nr   )r   r  rE  s    r?   _hasnazArrowExtensionArray._hasna@  s    ~(1,,rA   npt.NDArray[np.bool_]c                V   | j         j        }|dk    r-t          j        t	          |           t          j                  S |t	          |           k    r-t          j        t	          |           t          j                  S | j                                                                         S )z
        Boolean NumPy array indicating if each value is missing.

        This should return a 1-D array the same length as 'self'.
        r   r   )	r   r  r  ra  r&  r   onesrn  r  )r   r  s     r?   r   zArrowExtensionArray.isnaD  s     ^.
? 	68CIIRX66663t99$ 	673t99BH5555~%%''00222rA   Tskipnar  c                     | j         dd|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  r  )r  _reducer   r  kwargss      r?   r  zArrowExtensionArray.anyS  "    p t|;;&;F;;;rA   c                     | j         dd|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
        allr  )r  r  r  s      r?   r  zArrowExtensionArray.all  r  rA   	quicksortlast)	ascendingr  na_positionr  r  r   r  r   c               
   |rdnd}ddd                     |d           }|t          d|           t          j        | j        ||          }|                                }|                    t          j        d	          S )
Nr  
descendingat_endat_start)r  firstzinvalid na_position: )ordernull_placementFr   )	getr   r:   array_sort_indicesr   r  astyper  intp)	r   r  r  r  r  r  r  rr   	np_results	            r?   argsortzArrowExtensionArray.argsort  s      ):l"*Z@@DD[RVWW 	DB[BBCCC&N%
 
 
 OO%%	e444rA   methodc                   | j                                         d| j         j        fv s	| j        r+|s) t	          t                      d|           |          S | j         }t          j                            |j	                  r&|
                    t          j                              } t	          t          |          ||          }t          j        ||                                          S )Nr   argr  )
skip_nulls)r   lengthr  r  r`  r  rZ   r[   r   r\   r   r   r:   indexr2  )r   r  r  rZ  r  r  s        r?   _argmin_maxzArrowExtensionArray._argmin_max  s    >  ""q$.*C&DD 	CK	C &	C 47577N&NN336BBBB~8	** 	)99RXZZ((D#F##DV<<<xe$$**,,,rA   c                .    |                      |d          S )Nminr  r   r  s     r?   argminzArrowExtensionArray.argmin      ...rA   c                .    |                      |d          S )Nmaxr  r  s     r?   argmaxzArrowExtensionArray.argmax  r  rA   c                <     t          |           | j                  S )z
        Return a shallow copy of the array.

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

        Returns
        -------
        type(self)
        rK  rE  s    r?   r   zArrowExtensionArray.copy  s     tDzz$.)))rA   c                `     t          |           t          j        | j                            S )z|
        Return ArrowExtensionArray without NA values.

        Returns
        -------
        ArrowExtensionArray
        )r\   r:   	drop_nullr   rE  s    r?   dropnazArrowExtensionArray.dropna  s&     tDzz",t~66777rA   )limit
limit_arear   r   r  
int | Noner  #Literal['inside', 'outside'] | Nonec                  | j         s|                                 S ||t          j        |          }	 |dk    r/ t	          |           t          j        | j                            S |dk    r/ t	          |           t          j        | j                            S n# t          j
        $ r Y nw xY wt                                          ||||          S )Npadbackfill)r  r  r  r   )r  r   r    clean_fill_methodr\   r:   fill_null_forwardr   fill_null_backwardrZ   r   r  _pad_or_backfill)r   r  r  r  r   r  s        r?   r  z$ArrowExtensionArray._pad_or_backfill  s     { 	99;; 	Z 	.v66F
U? M%4::b&:4>&J&JKKKz) M%4::b&;DN&K&KLLLM.   
  ww'':D ( 
 
 	
s   4B! +4B! !B32B3r  object | ArrayLike | NoneFillnaOptions | Nonec                z   t          ||          \  }}| j        s|                                 S |%t                                          ||||          S |$t                                          |||          S t          |t          j        t          f          rOt          |          t          |           k    r/t          dt          |           dt          |                      	 |                     || j        j                  }nA# t          j        $ r/}dt!          |           d| j         }t%          |          |d }~ww xY w	  t          |           t'          j        | j        |                    S # t          j        $ r Y nw xY wt                                          ||||          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)r   r  r   r  r  r   r  r  r'   r&  r   r  r   r\   rZ   r  r   r   rC  r:   	fill_nullr   )	r   r  r  r  r   r  errr   r  s	           r?   r  zArrowExtensionArray.fillna&  s    /uf==v{ 	99;; 	V77>>fEPT>UUU 	I77>>u4>HHHebj.9:: 	 5zzSYY&  -c%jj - -!$T- -  
	*eT^5HIIJJ  	* 	* 	*HCJJHHDJHHCC..c)	*	4::bl4>jQQQRRR* 	 	 	
 D	 ww~~E&D~QQQs*   .!D E*E		E0F FFr   c                   t          |          s(t          j        t          |           t                    S t	          j        | j        t          j        |d                    }t          j        |t          j	                  S )Nr   Tr  )	value_set)
r&  r  ra  r   r:   is_inr   rZ   r   r   )r   r   rr   s      r?   isinzArrowExtensionArray.isinT  sj    6{{ 	38CIIT2222$.BHVQU4V4V4VWWW xbh////rA   tuple[np.ndarray, Any]c                P    | j                                         }|| j        j        fS )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'     ((**tz***rA   use_na_sentinel!tuple[np.ndarray, ExtensionArray]c                   |rdnd}| j         }|j        }t          rEt          j                            |          r&|                    t          j                              }t          j                            |j                  r|}n|	                    |          }|
                                dk    rWt          j        g t          j                  } t          |           t          j        g |j        j                            }n|                                }|j        }	|	j        dk    rt'          j        |	d          }	|	                    dd	
                              t          j        d          } t          |           |j                  }t          rLt          j                            |          r-t          t0          |                    | j                            }||fS )Nr  encode)null_encodingr   r   rc   r   FT)zero_copy_onlywritabler  )r   r\   r   rZ   r[   r   r   r   r  r  r  r  r   r  r   
value_typerS  indicesr  r:   r  r  r  
dictionaryr   r   )
r   r  r  rZ  r   encodedr  uniquescombined
pa_indicess
             r?   	factorizezArrowExtensionArray.factorizeo  s   
 #2?x~) 	)BH$8$8$A$A 	)99RXZZ((D8!!$),, 	JGG,,=,IIG>>q  	6hr111G d4jj!1"7<;R!S!S!STTGG --//H!)J$q( :\*b99
 )))NNUUe V  G !d4jj!455G 	LBH$8$8$A$A 	L.tz0J0JKKGrA   c                @    t          t          |            d          )NzA does not support reshape as backed by a 1D pyarrow.ChunkedArray.)r   r\   )r   argsr  s      r?   reshapezArrowExtensionArray.reshape  s,    !Dzz 7 7 7
 
 	
rA   r   decimalsc                d     t          |           t          j        | 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)r\   r:   roundr   )r   r  r  r  s       r?   r  zArrowExtensionArray.round  s+    , tDzz"(4>8DDDEEErA   r_   $NumpyValueArrayLike | ExtensionArraysideLiteral['left', 'right']sorterNumpySorter | Nonenpt.NDArray[np.intp] | np.intpc                   | j         rt          d          t          |t                    r|                    t
                    }d }t          | j        t                    r\| j        j        }t          j
                            |          st          j
                            |          r|j        dk    rt
          }|                     |                              |||          S )NzOsearchsorted requires array to be sorted, which is impossible with NAs present.r   r   )r  r  )r  r   r   r'   r  objectr   r1   r   rZ   r[   r   r   r   r  searchsorted)r   r  r  r  r   r   s         r?   r  z ArrowExtensionArray.searchsorted  s     ; 	$   e^,, 	)LL((Edj*-- 	z/H%%h//3583G3G3Q3Q-4'
 }}5}))66u4PV6WWWrA   r  r   
allow_fillr  r   c                   t          j        |          }t          | j                  dk    r'|dk                                    rt          d          |j        dk    r9|                                t          | j                  k    rt          d          |r|dk     }|                                rt          |t          | j                             t          j
        ||          }| j                            |          }t          |          r t          |           |          S  t          |           |          }|||<   |S  t          |           | j                            |                    S |dk                                     r:t          j        |          }||dk     xx         t          | j                  z  cc<    t          |           | j                            |                    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`.
        r   zcannot do a non-empty takez!out of bounds value in 'indices'.r  )r  
asanyarrayr&  r   r  r+  sizer  r-   rZ   r   r)  r   r\   r   )r   r  r  r  indices_array	fill_maskrr   s          r?   r)  zArrowExtensionArray.take  s   v g..t~!# 	;!);(@(@(B(B 	;9:::! 	Bm&7&7&9&9S=P=P&P 	B@AAA 	B%)I}} @ DN0C0CDDD "Y G G G,,];;
## .%4::f--- $dF++$.y! "tDzz$."5"5g">">??? !&&(( H " 6 6ma/000C4G4GG0004::dn11-@@AAArA   c                    | j         j        }t          j                            |          r|                                 S t          j                            |          r|                                 S | S )z"Maybe convert to a datelike array.)r   r\   rZ   r[   r   _to_datetimearrayr   _to_timedeltaarray)r   r   s     r?   _maybe_convert_datelike_arrayz1ArrowExtensionArray._maybe_convert_datelike_array&  se    .%8  )) 	-))+++X!!'** 	-**,,,rA   r   c                R   ddl m}m} | j        j        }t
          j                            |          sJ t          j	        d|j
         d          } ||j        |j
                  }| j                                        }|                    |          } |j        ||          S )z;Convert a pyarrow timestamp typed array to a DatetimeArray.r   )r   tz_to_dtypezM8[]r   )pandas.core.arrays.datetimesr   r
  r   r\   rZ   r[   r   r  r   r   r   r  r  _simple_new)r   r   r
  r   np_dtyper   rg  s          r?   r  z%ArrowExtensionArray._to_datetimearray/  s    	
 	
 	
 	
 	
 	
 	
 	

 .%x$$W-----81',11122GJ55>**,,??8,,(}(????rA   r   c                "   ddl m} | j        j        }t          j                            |          sJ t          j        d|j	         d          }| j        
                                }|                    |          } |j        ||          S )z;Convert a pyarrow duration typed array to a TimedeltaArray.r   r   zm8[r  r   )pandas.core.arrays.timedeltasr   r   r\   rZ   r[   r   r  r   r   r  r  r  )r   r   r   r  rg  s        r?   r  z&ArrowExtensionArray._to_timedeltaarray>  s    @@@@@@.%x##G,,,,,81',11122>**,,??8,,)~)((CCCCrA   c                    t          | j                  rt          j        | t                    S t                                                      S Nr   )r   r   r  asarrayr  r  _values_for_json)r   r  s    r?   r  z$ArrowExtensionArray._values_for_jsonI  s@    DJ'' 	2:d&1111ww'')))rA   npt.DTypeLike | Noner  r  c                V   |}t          | ||| j                  \  }}| j        j        }| j        r.t	          |          st
          j                            |          r| }n|                     |          }d}t
          j        	                    |          st
          j        
                    |          rP|t          k    r|| j        j        u rt          j        }|                                                    ||          }n#t
          j                            |          st
          j                            |          rCt)          j        t-          |          |          }|j        r|||                                <   nt
          j                            |          r9|t	          |          rd }t)          j        t1          |          ||          }nJ|j        rJt
          j                            |          rt|t(          j        u s|t          j        u rXt7          |          rI|j                                        }||                    |d          }|r|                                }n|Nt          j        g |                              d          }t=          ||          r|j        }nt(          j        }t)          j         t1          |          |          }|                                }	|||	<   ||	          j                                        ||	 <   |S )NFr   r  r   )r  r   r  rc   r  )!r&   r  r   r\   r   rZ   r[   rn  r  r   r   r  r   r  r	   
no_defaultr  r  r   r   r  r   r_  fullr&  r   nanr   r  r   r   object_empty)
r   r   r   r  original_na_valuer   rZ  rr   r  r  s
             r?   r  zArrowExtensionArray.to_numpyN  s    %24$+VVx.%{ 	d8nn 	0@0@0I0I 	DD;;x((DD8  )) (	=RX-A-A'-J-J (	= *8tz/B#B *>7799BBh C  FF Xg&& !	="(*:*:7*C*C !	= Xd4jj666F{ /&.tyy{{#Xg&& 	=  T(^^  WSYY85IIIFF 	=H  ))	= BF"	= %6		=
 #5))	= ^,,..F :u599 ' ''222;;5;QQ#E844 '!KEEJEXc$iiu555F99;;D#F4L $K1::<<FD5MrA   c                    t          | j                  r$t          |                                 ||          S t	                                          ||          S )N)	na_action)r   r   r#   r  r  map)r   mapperr   r  s      r?   r!  zArrowExtensionArray.map  sJ    DJ'' 	2T]]__f	JJJJ77;;vy111rA   r  keepLiteral['first', 'last', False]c                   | j         j        }t          j                            |          st          j                            |          r|                     d          }nt          j                            |          r|                     d          }nt          j                            |          rk|j	        dk    rt          j
                    }nt          j                    }|                     t          |                    }|                    d          }n|                                 d         }| j        r|                                 nd }t#          j        |||          S )Nr   )r  F    )r#  r  )r   r\   rZ   r[   r   r   r  r   is_temporal	bit_widthint32r   r  r1   r  r  r   algos
duplicated)r   r#  r   r   r   r  s         r?   r+  zArrowExtensionArray.duplicated  s3    .%8(( 	)BH,?,?,H,H 	)]]A]..FFX  )) 	)]]E]22FFX!!'** 
	) B& %(**(**++j1122C\\1\--FF ^^%%a(F"k3tyy{{{tT====rA   c                   | j         j        }t          rKt          j                            |          r,| j                             t          j                              }n| j         }t          j	        |          }t          r4t          j                            |          r|                    |          } t          |           |          S )z
        Compute the ArrowExtensionArray of unique values.

        Returns
        -------
        ArrowExtensionArray
        )
r   r\   r   rZ   r[   r   r   r   r:   unique)r   r   rZ  	pa_results       r?   r-  zArrowExtensionArray.unique  s     .% 	"BH$8$8$A$A 	">&&rxzz22DD>DIdOO	 	0BH$8$8$A$A 	0!w//ItDzz)$$$rA   r  r   c                   | j         j        }t          rKt          j                            |          r,| j                             t          j                              }n| j         }ddlm	}m
} |                                }|                    d          }|                    d          }|rI|j        dk    r>|                                }	|                    |	          }|                    |	          }t          r4t          j                            |          r|                    |          }t!          |          } | t          |           |                    }
 |||
dd          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   rd   countF)r  r'  r   )r   r\   r   rZ   r[   r   r   r   pandasr0  r   value_countsfieldr  is_validr*  r   )r   r  r   rZ  r0  r   vcr   countsr  r  s              r?   r3  z ArrowExtensionArray.value_counts  sf   " .% 	"BH$8$8$A$A 	">&&rxzz22DD>D	
 	
 	
 	
 	
 	
 	
 	

   !! 	)do) 	)??$$D]]4((F]]4((F 	*BH$8$8$A$A 	*[[))F$V,,jd4jj(())vfEeDDDDrA   c                    d |D             }|d         j         dk    rt          j                    }n|d         j         j        }t          j        ||          } | |          S )z
        Concatenate multiple ArrowExtensionArrays.

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

        Returns
        -------
        ArrowExtensionArray
        c                J    g | ] }|j                                         D ]}|!S  r   
iterchunks).0ear   s      r?   
<listcomp>z9ArrowExtensionArray._concat_same_type.<locals>.<listcomp>  s3    SSSB9P9P9R9RSS%SSSSrA   r   r   rc   )r   rZ   large_stringr   r   )r   	to_concatchunksr   r   s        r?   _concat_same_typez%ArrowExtensionArray._concat_same_type  sl     TS)SSSQ<) 	8((HH |)7HvH555s3xxrA   r'  $ArrowExtensionArray | ExtensionArrayc               v   ddddd                     ||          }t          t          |d          }| t                      j        |fd|i|S | j        }|j        }t          j        	                    |          o|dv p$t          j        
                    |          o|d	k    }|rX|j        d
k    r'|                    t          j                              }n&|                    t          j                              } ||fd|i|}	|r|	                    |          }	 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  )rJ  rK  rM  r&  r  )r  r`  r:   r  _accumulater   r\   rZ   r[   r'  r   r(  r   r)  r   )r   r'  r  r  pyarrow_namepyarrow_methdata_to_accumr   convert_to_intrr   r  s             r?   rN  zArrowExtensionArray._accumulate  s_   > '&0.	
 

 #dD// 	 r<66 	F&577&tEEFEfEEE % H  **Kt7K/KCh""8,,A1A 	  	?!R' ? - 2 228:: > > - 2 228:: > >mIII&II 	+[[**FtDzz&!!!rA   c               
     j         j        } j         }t          ri nddi}|dv rt          j                            |          s]t          j                            |          s>t          j                            |          st          j                            |          rjt          j                            |          r, j         	                    t          j
                              }n j         }t          j        |d          }|}n|dv rKt          j                            |          r, j         	                    t          j
                              }n|dv rt          j                            |          rd|j        }	|	dk    r, j         	                    t          j                              }n+ j         	                    t          j
                              }|dk    r fd	}
nOd
dddd                    ||          }t#          t          |d          }
|
 t%                      j        |fd|i|S |dv r
d|vrd|d<   n|dk    rd|d<   	  |
|fd|i|}nb# t(          t*          t,          f$ rH}dt                     j         d j         d| dt          j         d| d}t-          |          |d}~ww xY w|dk    r|d         }t          j        |                                          r|S |dv r4t          j                            |          r|	                    |          }|dv rt          j                            |          rht          sL|j        }	|	dk    r  |j	        t          j                    fi |}n |j	        t          j
                    fi |}|	                    |          }|dv r=t          j                            |          r |j	        t          j
                    fi |}t          j                            |          r|	                    |          }nt          j                            |          r7t;          |          }|	                    t          j        |                    }nst          j                            |          r(|	                    t          j        d                    }n,|	                    t          j        |j                             }|S )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
        rY   F)r  r  r   )r  r  sum)medianmeanstdsemr&  rX  c                    t          j        | fd|i|}t          j        t          j        j                            }t          j        ||          S )Nr  )r:   stddevsqrt_checkedr1  r   re   )rZ  r  r  	numeratordenominatorr   s        r?   rP  z9ArrowExtensionArray._reduce_pyarrow.<locals>.pyarrow_meth{  sM    IdLLzLVLL	 obht~.F.FGG(K@@@rA   quantileproductrZ  variance)rU  prodrW  varNr  	min_countrU  g      ?qr  'z' with dtype z does not support reduction 'z' with pyarrow version z. 'z(' may be supported by upgrading pyarrow.)rU  rV  )rW  rX  r   )!r   r\   r   rZ   r[   r   r   r   r   r   r   r:   rg   r'  r(  r)  r  r`  r  r  AttributeErrorr   rC  r^  r   __version__rn  r2  r   r   r  r   r   )r   r'  r  r  r   data_to_reducecast_kwargsdata_to_cmpnot_eqnbitsrP  rO  rr   r  r   r   r  s   `               r?   _reduce_pyarrowz#ArrowExtensionArray._reduce_pyarrow@  sO   0 .%0Ebbvuo>! 	AH((	Ax##G,,	A x##G,,	A x""7++		A x##G,, -"n11"(**=="n\+q11F#NN** 	Arx/C/CG/L/L 	A!^00<<NN55 	A"(:N:Nw:W:W 	A%E{ A!%!4!4RXZZ!@!@!%!4!4RXZZ!@!@5= 	FA A A A A A %!!	 
 c$oo  #2|T::L F&uwwtEEFEfEEE >! 	k&? 	"#F;X 	F3K		*!\.NNVNvNNFF 3Y? 	* 	* 	*&DJJ' & &dj & &/3& &>& &.2& & &  C..c)	* 8 	AYF:f##%% 	M(( 	*RX-A-A'-J-J 	*[[))F%% 	*"(*>*>w*G*G 	*' D)B; D(V[CC{CCFF(V[CC{CCF[[))F>! 	@bh&:&:7&C&C 	@ V[;;{;;Fx##G,, 
@W--!!'** @-g66R[%6%677!!'** @R[%5%566  R[%>%>??s   I$ $K;AJ>>Kr  keepdimsro  c                    | j         |f||d|}t          |t          j                  r t	          |           |          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
        rn  )_reduce_calcr   rZ   r   r\   )r   r'  r  ro  r  rr   s         r?   r  zArrowExtensionArray._reduce  sT    4 #"4TTTVTTfbh'' 	4::f%%%MrA   c                   | j         |fd|i|}|rt          |t          j                  r/t          j        |                                g|j                  }n7t          j        |gt          t          |          d                             }|S t          j
        |                                          r| j        j        S t          |t          j                  r|                                S |S )Nr  rc   r   )rm  r   rZ   r   r   r2  r\   r   r   r:   rn  r   r  )r   r'  r  ro  r  r.  rr   s          r?   rq  z ArrowExtensionArray._reduce_calc  s     )D(GGfGGG	 	)RY// 9??#4#4"5INKKKK()@)K)KA)NOO   M:i  &&(( 	:&&	29-- 	??$$$rA   c                   t           j                            | j        j                  s t                                                      S | }t           j                            |j	                  }|
                    d                                          }t          j        dg| j	        j                  }|dk    }|                                r2|                                }|||<   |                                }d||<   |                    |          } t          |           t           j                            |j	                            }||fS )z-
        See Series.explode.__doc__.
        rd   Nrc   r   )rZ   r[   is_listr   r   r  _explodecomputelist_value_lengthr   r  r  rj   r\   r  r   r  list_flatten)r   r   r7  r  r  r  s        r?   ru  zArrowExtensionArray._explode  s    x
 899 	&77##%%%--f.>??!!!$$--//YvDN,?@@@
{88:: 	[[]]F%F4L[[]]FF4Lz**dBJ33F4DEEFFv~rA   c                ,   t          |t                    rt          |          dk    r|d         }t          | |          }|                     |          }t          j        |          r|                     d|| j                  }nt          |          rt          t          |          }t          |           }|dk     r||z  }d|cxk    r|k     sn t          d| d|           t          |t          j                  r|                                }nt!          |          rt#          d          g | j        d|         j        t          j        |g| j        j        d          | j        |dz   d         j        }t          j        |                                          }nt/          |          r>t1          j        |t0          j        	          }|                     | j        ||          }nbt9          |          st          |t          j                  rOt1          j        t          |           t0          j        	          }d||<   |                     ||| j                  }nt1          j        t          |                     |         }t          |          t          |          k    rt#          d          t          |          dk    rdS t1          j        |          }||         }|                     |          }t1          j        t          |           t0          j        	          }d||<   |                     | j        ||          }t          |t          j!                  rt          j        |g          }|| _        dS )
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
        rd   r   Tzindex z' is out of bounds for axis 0 with size z%Length of indexer and values mismatchNr   r   )"r   r,  r&  r+   _maybe_convert_setitem_valuecomis_null_slice_if_elser   r   r   r  r+  rZ   r   r2  r   r   rB  r   r\   r   rS  r   r  r  r   _replace_with_maskr   ra  aranger  r)  r   )	r   r  r  rZ  nrB  r  r  r  s	            r?   __setitem__zArrowExtensionArray.__setitem__  si   , c5!! 	c#hh!m 	a&C!$,,11%88S!! -	H==udn==DD__ )	HsC..CD		AQw q    a     LSLLLL   %++ Je$$ J !HIII%,%t~':MMM a		*1F
 #F++::<<DD3 	H*S111C**4>3FFDDu 	HE29!=!= 	H8CIIRX666DDI==udn==DD iD		**3/G7||s5zz) J !HIII7||q  j))Gg&GJJw''E8CIIRX666D DM**4>4GGDdBH%% 	,#TF++DrA   averageaxisr  	na_optionr  pctr  r   r  r  c               j   |dk    rnt                                          |||||          }|dk    s|rt          j                    }nt          j                    }t          j        ||d          }|S | j                                        }	|rdnd}
|dk    rd	nd
}|dk    rdn|}t          j	        |	|
||          }|dk    rJt          j
        | j                  }t          j        d |j                  }t          j        |||          }|dk    rt          j	        |	|
|d          }|                    t          j                              }|                    t          j                              }t          j        t          j        ||          d          }|rt          j                            |j                  s&|                    t          j                              }|dk    rt          j        |          }nt          j        |          }t          j        ||          }|S )Nr   r  r  Tr   r  r  topr  r  r  )	sort_keysr  
tiebreakerr#  rc   r     dense)r  _rankrZ   r]   uint64r   r   rS  r:   rankrn  rj   r\   rk   r   rm   rt   r[   r   r  r1  )r   r  r  r  r  r  rankedr   rr   rZ  r  r  r  r  null
result_max
result_mindivisorr  s                     r?   
_rank_calczArrowExtensionArray._rank_calc[  s.    19 	WW]]## #  F " &c &*,,)++Xf7EEEFM~,,..#,>KK,	'0E'9Gx$	1=UUv
)!	
 
 
  	4:dn--D9T444DZdF33FY 		B#- 	  J $66JRZ\\22JYrvj*==qAAF 	08''44 3RZ\\22  +&..(6**Yvw//FrA   c          	     b     t          |           |                     |||||                    S )z*
        See Series.rank.__doc__.
        r  )r\   r  )r   r  r  r  r  r  s         r?   r  zArrowExtensionArray._rank  sC     tDzzOO##   
 
 	
rA   qsnpt.NDArray[np.float64]interpolationc                   | j         j        }| j         }t          j                            |          rZ|j        }|dk    r'|                    t          j                              }n&|                    t          j                              }t          j
        |||          }t          j                            |          rt          j                            |j                  rt          j        |          }|j        }|dk    r'|                    t          j                              }n&|                    t          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&  )rd  r  )r   r\   rZ   r[   r'  r(  r   r)  r   r:   r^  r   rn   )r   r  r  r   rZ  rl  rr   s          r?   	_quantilezArrowExtensionArray._quantile  s5    >&~8)) 	- &E{ -yy,,yy,,TR}EEE8)) 	+x##FK00 *&))&E{ 1RXZZ00RXZZ00[[**FtDzz&!!!rA   c           
     z   | j         j        }t          j                            |          rz|j        }|dk    r,| j                             t          j                              }nH|dk    r,| j                             t          j                              }nt          |          | j         }|r|
                                }t          j        |          }|                    d                              t          j        |                    d          t          j        |                    d                                        }t          j                            |          r|                    |          }|                    t          j        |                    } 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   r7  )r   r\   rZ   r[   r'  r(  r   r)  r   r   r  r:   r3  r4  r*  r   r  r)  r  )r   r  r   rl  rZ  resmost_commons          r?   _modezArrowExtensionArray._mode  sn     .%8(( 		"%E{ 3~**28::66" 3~**28::66)'222>D 	$>>##Dod##ii))00HSYYx(("&81D1D*E*EFF
 
 8(( 	4%**733K!&&r'<['I'IJJtDzz+&&&rA   c                    	 |                      || j        j                  }nA# t          j        $ r/}dt          |           d| j         }t          |          |d}~ww xY w|S )z-Maybe convert value to be pyarrow compatible.r  r  N)r  r   r\   rZ   r  r   r   rC  )r   r  r  r   s       r?   rz  z0ArrowExtensionArray._maybe_convert_setitem_value  su    	*LL(;<<EE  	* 	* 	*HCJJHHDJHHCC..c)	* s    # A!*AA!r   c                  |                                  }	| j        j        dk    r| j                                        }
n=| j        j        dv r|                     dd          }
nt          d| j                   t          j        |
f|d|||||	d|  t          |           | 	                    t          j        |
|		                              S )
z2
        See NDFrame.interpolate.__doc__.
        r  r$  f8g        r  z)interpolate is not implemented for dtype=r   )r  r  r  r  limit_directionr  r  r   )r   r   r  r   r  r   r    interpolate_2d_inplacer\   r   rZ   r   )r   r  r  r  r  r  r  r   r  r  rZ  s              r?   interpolatezArrowExtensionArray.interpolate  s      yy{{:?c! 	>**,,DDZ_$ 	==tc=::DD%HDJHH   	&
	
+!
	
 
	
 
	
 
	
 
	
 tDzz$,,RXd-F-F-FGGHHHrA   condnpt.NDArray[np.bool_] | boolArrayLike | Scalarra   c                    	 t          j        |||          S # t          j        $ r Y nw xY wdd} ||          \  }} ||          \  }}|p|}t	          j        |||          }t          j        ||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
        rV   %tuple[np.ndarray, pa.DataType | None]c                   t          | t          j        t          j        f          r| j        }n8t          | t          j                  r| j        }|                                 } nd }t          j        | t                    |fS r  )
r   rZ   r   r   r\   r   r2  r  r   r  )r  r   s     r?   _to_numpy_and_typez8ArrowExtensionArray._if_else.<locals>._to_numpy_and_typeN  so    %"(BO!<== *E29-- *8E000'99rA   Tr   )rV   r  )r:   rk   rZ   r   r  wherer   )	r   r  r_   ra   r  	left_type
right_typer   rr   s	            r?   r}  zArrowExtensionArray._if_else2  s    .	:dD%000* 	 	 	D		: 	: 	: 	: -,T22i..u55z)z$e,,xW$????s    **r  replacementsc                   t          |t          j                  r|                                }t          |t          j                  r8t          j                            |j                  r|                                }	 t          j        |||          S # t          j	        $ r Y nw xY wt          |t          j
                  rt          j        |t                    }n.t          |t          j                  r|                                }t          j        |t                    }|||<   t          j        ||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   rZ   r   rS  r[   r   r\   r:   replace_with_maskr   r   r  r   r  r   r2  )r   r   r  r  rr   s        r?   r~  z&ArrowExtensionArray._replace_with_mask^  s+   0 lBO44 	9'6688Lfbo.. 	-283F3Fv{3S3S 	- **,,F	'lCCC* 	 	 	D	lBH-- 	08L???LLbi00 	0'--//L&///#txV[dCCCCs   B B*)B*c                   | j         j        }t          j                            |          st          j                            |          rd}n)t          j                            |          rd}nt          t                      |         }| 	                                }| 
                    |j        |          } |                                ||          S )Nrd   Tr  )r   r\   rZ   r[   r   r   r   r   r/   r   r  numpy_dtypeconstruct_array_type)r   r   r  r   r  r   s         r?   
_to_maskedzArrowExtensionArray._to_masked  s    >&8)) 	&RX-@-@-J-J 	&HHX  ** 	&HH%%$&&x0yy{{mm%"3hmGG+u))++C666rA   howhas_dropped_narc  ngroupsidsnpt.NDArray[np.intp]c          	     ,   t          | j        t                    r t                      j        d|||||d|S | j        j        }t          j        	                    |          r| 
                                }nHt          j                            |          r|                                 }n|                                 } |j        d|||||d|}	t          |	t          j                  r|	S t          |                               |	d          S )N)r  r  rc  r  r  Fr  r:  )r   r   r*   r  _groupby_opr   r\   rZ   r[   r   r  r   r  r  r  r  r   )r   r  r  rc  r  r  r  r   r   rr   r  s             r?   r  zArrowExtensionArray._groupby_op  s9    dj+.. 	&577& -#     .%8  )) 	'++--FFX!!'** 	',,..FF__&&F## 
)
 
 
 
 fbj)) 	MDzz((e(<<<rA   funcr   list[list[Any]]c                N    fd| j                                         D             S )zJApply a callable to each element while maintaining the chunking structure.c                T    g | ]$}fd |                     d          D             %S )c                .    g | ]}|d n
 |          S r9   r:  )r=  r8  r  s     r?   r?  zEArrowExtensionArray._apply_elementwise.<locals>.<listcomp>.<listcomp>  s:        2c  rA   Fr  r?  )r=  chunkr  s     r?   r?  z:ArrowExtensionArray._apply_elementwise.<locals>.<listcomp>  sZ     
 
 

 	    >>>??  
 
 
rA   r;  )r   r  s    `r?   _apply_elementwisez&ArrowExtensionArray._apply_elementwise  s>    
 
 
 

 2244
 
 
 	
rA   patflagsc                    |rt          d|           t          |           t          j        | j        |                    S )Nz!count not implemented with flags=)r   r\   r:   count_substring_regexr   )r   r  r  s      r?   
_str_countzArrowExtensionArray._str_count  sG     	N%&LE&L&LMMMtDzz"24>3GGHHHrA   caseregexc                    |rt          d|          |rt          j        }nt          j        } || j        ||           }t          |          s|                    |          } t          |           |          S )Nz$contains not implemented with flags=)ignore_case)r   r:   match_substring_regexmatch_substringr   r   r  r\   )r   r  r  r  nar  pa_containsrr   s           r?   _str_containsz!ArrowExtensionArray._str_contains  s      	Q%&Ou&O&OPPP 	-2KK,KT^S$hGGGBxx 	*%%b))FtDzz&!!!rA   str | tuple[str, ...]c                   t          |t                    rt          j        | j        |          }nt          |          dk    r.t          j        t          j        | j                  d d          }n\t          j        | j        |d                   }|dd          D ]0}t          j        |t          j        | j        |                    }1t          |          s|
                    |          } t          |           |          S Npatternr   Frd   )r   r   r:   starts_withr   r&  rk   rn  rH   r   r  r\   r   r  r  rr   ps        r?   _str_startswithz#ArrowExtensionArray._str_startswith  s    c3 	W^DNC@@@FF3xx1} W BJt~$>$>eLLAGGGQRR W WAVFBN4>ST,U,U,UVVFFBxx 	*%%b))FtDzz&!!!rA   c                   t          |t                    rt          j        | j        |          }nt          |          dk    r.t          j        t          j        | j                  d d          }n\t          j        | j        |d                   }|dd          D ]0}t          j        |t          j        | j        |                    }1t          |          s|
                    |          } t          |           |          S r  )r   r   r:   	ends_withr   r&  rk   rn  rH   r   r  r\   r  s        r?   _str_endswithz!ArrowExtensionArray._str_endswith  s    c3 	U\$.#>>>FF3xx1} U BJt~$>$>eLLdnc!fEEEQRR U UAVFBLQR,S,S,STTFFBxx 	*%%b))FtDzz&!!!rA   r   str | re.Patternreplstr | Callabler  c                   t          |t          j                  st          |          s|r|rt	          d          |rt
          j        nt
          j        }|dk     rd n|} || 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   r\   )
r   r  r  r  r  r  r  r  pa_max_replacementsrr   s
             r?   _str_replacez ArrowExtensionArray._str_replace	  s     c2:&& 	(4.. 	 	 	%*  
 .3Lr))8L '(!e2ddN0	
 
 
 tDzz&!!!rA   repeatsint | Sequence[int]c                    t          |t                    s$t          dt          |          j                    t          |           t          j        | j        |                    S )Nz*repeat is not implemented when repeats is )r   r  r   r\   r^  r:   rm  r   )r   r  s     r?   _str_repeatzArrowExtensionArray._str_repeat 	  sb    '3'' 	I%UT']]=SUU   4::b.t~wGGHHHrA   r  Scalar | Nonec                j    |                     d          sd| }|                     ||||d          S )N^T)r  )
startswithr  r   r  r  r  r  s        r?   
_str_matchzArrowExtensionArray._str_match(	  sB     ~~c"" 	c))C!!#tUBd!CCCrA   c                    |                     d          r|                     d          r| d}|                     ||||          S )N$z\$)endswithr  r  s        r?   _str_fullmatchz"ArrowExtensionArray._str_fullmatch/	  sN     ||C   	CLL$7$7 	)))CsD%444rA   rx   r/  endc                   |dk    r|t          j        | j        ||          }t          j        ||          }t          j        |d          }t          d|          }t          j        ||          }t          j        |||          }n=|dk    r|| j        }t          j        ||          }nt          d|d|d|           t          |           |          S )Nr   )r0  r   zfind not implemented with sub=z, start=z, end=)
r:   utf8_slice_codeunitsr   find_substringr   r  rt   rk   r   r\   )	r   rx   r/  r  slicesrr   	not_foundstart_offsetoffset_results	            r?   	_str_findzArrowExtensionArray._str_find6	  s    A: 	# 	,T^UMMMF&vs33F,,Iq%==LF6<88MZ	6=AAFFaZ 	C 	^F&vs33FF%ESEEUEEsEE   tDzz&!!!rA   rr  c                   t           j                            | j        j                  s)t           j                            | j        j                  rT|                     t                    }t          j        |t          j	        t          j
                                        }n| j        } t	          |           t          j        ||                    S )Nrc   )rZ   r[   r   r   r\   r   r  r_  r   list_r   r:   binary_join)r   rr  rr   s      r?   	_str_joinzArrowExtensionArray._str_joinG	  s    8dn122 	$bh6N6NN7
 7
 	$ ,,T22F%f28BIKK3H3HIIIFF^FtDzz".55666rA   expandc                    fd}|                      |          } t          |           t          j        |                    S )Nc                .    |                                S r9   )	partitionr8  rr  s    r?   r@   z4ArrowExtensionArray._str_partition.<locals>.<lambda>R	  s    c 2 2 rA   r  r\   rZ   r   r   rr  r  	predicaterr   s    `   r?   _str_partitionz"ArrowExtensionArray._str_partitionQ	  sE    2222	((33tDzz"*622333rA   c                    fd}|                      |          } t          |           t          j        |                    S )Nc                .    |                                S r9   )
rpartitionr  s    r?   r@   z5ArrowExtensionArray._str_rpartition.<locals>.<lambda>W	  s    s 3 3 rA   r  r  s    `   r?   _str_rpartitionz#ArrowExtensionArray._str_rpartitionV	  sE    3333	((33tDzz"*622333rA   r0  r1  c                x    |d}|d} t          |           t          j        | j        |||                    S )Nr   rd   )r/  r0  r1  )r\   r:   r  r   )r   r/  r0  r1  s       r?   
_str_slicezArrowExtensionArray._str_slice[	  sR      	E 	DtDzz#DN%dQUVVV
 
 	
rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_alnumr   rE  s    r?   _str_isalnumz ArrowExtensionArray._str_isalnumf	  %    tDzz"*4>::;;;rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_alphar   rE  s    r?   _str_isalphaz ArrowExtensionArray._str_isalphai	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_decimalr   rE  s    r?   _str_isdecimalz"ArrowExtensionArray._str_isdecimall	  %    tDzz",T^<<===rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_digitr   rE  s    r?   _str_isdigitz ArrowExtensionArray._str_isdigito	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_lowerr   rE  s    r?   _str_islowerz ArrowExtensionArray._str_islowerr	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_numericr   rE  s    r?   _str_isnumericz"ArrowExtensionArray._str_isnumericu	  r!  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_spacer   rE  s    r?   _str_isspacez ArrowExtensionArray._str_isspacex	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_titler   rE  s    r?   _str_istitlez ArrowExtensionArray._str_istitle{	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_is_upperr   rE  s    r?   _str_isupperz ArrowExtensionArray._str_isupper~	  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   utf8_lengthr   rE  s    r?   _str_lenzArrowExtensionArray._str_len	  rP  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   
utf8_lowerr   rE  s    r?   
_str_lowerzArrowExtensionArray._str_lower	  $    tDzz"-77888rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   
utf8_upperr   rE  s    r?   
_str_upperzArrowExtensionArray._str_upper	  r:  rA   c                    |t          j        | j                  }nt          j        | j        |          } t	          |           |          S N)
characters)r:   utf8_trim_whitespacer   	utf8_trimr\   r   to_striprr   s      r?   
_str_stripzArrowExtensionArray._str_strip	  sK     	G,T^<<FF\$.XFFFFtDzz&!!!rA   c                    |t          j        | j                  }nt          j        | j        |          } t	          |           |          S r?  )r:   utf8_ltrim_whitespacer   
utf8_ltrimr\   rC  s      r?   _str_lstripzArrowExtensionArray._str_lstrip	  K     	H-dn==FF]4>hGGGFtDzz&!!!rA   c                    |t          j        | j                  }nt          j        | j        |          } t	          |           |          S r?  )r:   utf8_rtrim_whitespacer   
utf8_rtrimr\   rC  s      r?   _str_rstripzArrowExtensionArray._str_rstrip	  rJ  rA   prefixc                   t           sut          j        | j                  }t          j        | j        t                              }t          j        ||| j                  } t          |           |          S fd}|                     |          } t          |           t          j
        |                    S )Nr  c                .    |                                S r9   )removeprefix)r8  rO  s    r?   r@   z7ArrowExtensionArray._str_removeprefix.<locals>.<lambda>	  s     0 0 8 8 rA   )r   r:   r  r   r  r&  rk   r\   r  rZ   r   )r   rO  r  removedrr   r  s    `    r?   _str_removeprefixz%ArrowExtensionArray._str_removeprefix	  s    # 	&.HHHK-dnc&kkJJGZWdnEEF4::f%%%8888	((33tDzz"*622333rA   c                    d }|                      |          } t          |           t          j        |                    S )Nc                *    |                                  S r9   )casefold)r8  s    r?   r@   z3ArrowExtensionArray._str_casefold.<locals>.<lambda>	  s     rA   r  )r   r  rr   s      r?   _str_casefoldz!ArrowExtensionArray._str_casefold	  s>    ..	((33tDzz"*622333rA   strictencodingr   c                    fd}|                      |          } t          |           t          j        |                    S )Nc                0    |                                S r9   )r  )r8  rZ  r   s    r?   r@   z1ArrowExtensionArray._str_encode.<locals>.<lambda>	  s    

8V < < rA   r  )r   rZ  r   r  rr   s    ``  r?   _str_encodezArrowExtensionArray._str_encode	  sI    <<<<<	((33tDzz"*622333rA   c                    |rt          d          t          j        |          j                                        }t          |          dk    rt          d|d          t          j         j	        |          |r4 fdt          |t          j        j                            D             S  t                     t          j        dg                    S )NzOnly flags=0 is implemented.r   zpat=z$ must contain a symbolic group name.c           	     p    i | ]2\  }}| t                    t          j        |g                    3S r:  )r\   r:   struct_field)r=  colirr   r   s      r?   
<dictcomp>z4ArrowExtensionArray._str_extract.<locals>.<dictcomp>	  sM       C ZT$ZZ < <==  rA   )r   r  compile
groupindexkeysr&  r   r:   extract_regexr   zipranger\   
num_fieldsr`  )r   r  r  r  groupsrr   s   `    @r?   _str_extractz ArrowExtensionArray._str_extract	  s     	F%&DEEEC+0022v;;! 	LJJJJKKK!$.#66 	<    !&%0F*G*GHH   
 4::bofqc::;;;rA   c                    t          j        ||          fd}|                     |          } t          |           t	          j        |                    S )N)r  c                .                         |           S r9   )findall)r8  r  s    r?   r@   z2ArrowExtensionArray._str_findall.<locals>.<lambda>	  s    c 2 2 rA   )r  rd  r  r\   rZ   r   )r   r  r  r  rr   r  s        @r?   _str_findallz ArrowExtensionArray._str_findall	  sY    
3e,,,2222	((33tDzz"*622333rA   |c                X   t          j        | j        |          }t          j        |          }|                                }|                    t          j                            |                    }t          j	        |          
                    d                                          }t          |           }t          |          }t          j        ||                                          }	|	t          j        |                              |          |z  z   }	t          j        ||z  t          j                  }
d|
|	<   |
                    ||f          }
 t)          |           t          j        t-          |
                              }||                                fS )Nr   r   T)r:   split_patternr   rx  r-  r)  rZ   rv  r  rw  r  r  r&  index_inr  r  repeatra  r   r  r\   r   r_  	to_pylist)r   rr  r   flattened_valuesr  uniques_sortedlengthsn_rowsn_colsr  dummiesrr   s               r?   _str_get_dummiesz$ArrowExtensionArray._str_get_dummies	  sS    55?511"))++ bj&C&CG&L&LMM&u--77::CCEETW+.??HHJJBIf--44W==FF(6F?"(;;;//66"233dBHT']]3344~//1111rA   c                    fd}|                      |          } t          |           t          j        |                    S )Nc                2    |                                S r9   )r  r8  r  r/  rx   s    r?   r@   z0ArrowExtensionArray._str_index.<locals>.<lambda>	      		#uc : : rA   r  r   rx   r/  r  r  rr   s    ```  r?   
_str_indexzArrowExtensionArray._str_index	  M    ::::::	((33tDzz"*622333rA   c                    fd}|                      |          } t          |           t          j        |                    S )Nc                2    |                                S r9   )rindexr  s    r?   r@   z1ArrowExtensionArray._str_rindex.<locals>.<lambda>	  s    

3s ; ; rA   r  r  s    ```  r?   _str_rindexzArrowExtensionArray._str_rindex	  sM    ;;;;;;	((33tDzz"*622333rA   formc                    fd}|                      |          } t          |           t          j        |                    S )Nc                .    t          j        |           S r9   )unicodedata	normalize)r8  r  s    r?   r@   z4ArrowExtensionArray._str_normalize.<locals>.<lambda>	  s     5dC @ @ rA   r  )r   r  r  rr   s    `  r?   _str_normalizez"ArrowExtensionArray._str_normalize	  sE    @@@@	((33tDzz"*622333rA   c                    fd}|                      |          } t          |           t          j        |                    S )Nc                2    |                                S r9   )rfindr  s    r?   r@   z0ArrowExtensionArray._str_rfind.<locals>.<lambda>	  r  rA   r  r  s    ```  r?   
_str_rfindzArrowExtensionArray._str_rfind	  r  rA   
str | Nonec                   |dv rd }|t           j        }nC|r!t          j        t           j        |          }n t          j        t           j        |          } t          |            || j        |                    S )N   r   r   r  )
max_splits)r:   utf8_split_whitespace	functoolspartialsplit_pattern_regexrs  r\   r   )r   r  r  r  r  
split_funcs         r?   
_str_splitzArrowExtensionArray._str_split	  s     < 	A 	J1JJ 	J"*2+A3OOOJJ"*2+;SIIIJtDzz**T^BBBCCCrA   c                    |dv rd }|2 t          |           t          j        | j        |d                    S  t          |           t          j        | j        ||d                    S )Nr  T)r  reverse)r\   r:   r  r   rs  )r   r  r  s      r?   _str_rsplitzArrowExtensionArray._str_rsplit	  s    < 	A 	4::(AtTTT   4:: DQQQ  rA   tabledict[int, str]c                    fd}|                      |          } t          |           t          j        |                    S )Nc                .    |                                S r9   )	translate)r8  r  s    r?   r@   z4ArrowExtensionArray._str_translate.<locals>.<lambda>

  s    e 4 4 rA   r  )r   r  r  rr   s    `  r?   _str_translatez"ArrowExtensionArray._str_translate	
  sE    4444	((33tDzz"*622333rA   widthc                    ||d<   t          j        di |fd}|                     |          } t          |           t	          j        |                    S )Nr  c                T    d                                         |                     S )N
)joinwrap)r8  tws    r?   r@   z/ArrowExtensionArray._str_wrap.<locals>.<lambda>
  s    		"''#,, 7 7 rA   r:  )textwrapTextWrapperr  r\   rZ   r   )r   r  r  r  rr   r  s        @r?   	_str_wrapzArrowExtensionArray._str_wrap
  sd    w!++F++7777	((33tDzz"*622333rA   c                     t          |           t          j        |                                 j        dt          j                                        S NT)r   r\   )r\   rZ   r   r  daysr)  rE  s    r?   _dt_dayszArrowExtensionArray._dt_days
  sE    tDzzHT,,..3BHJJWWW
 
 	
rA   c                     t          |           t          j        d |                                 D             t          j                                        S )Nc                <    g | ]}|t           ur|j        j        nd S r9   )r
   
componentshoursr=  tds     r?   r?  z1ArrowExtensionArray._dt_hours.<locals>.<listcomp>
  s;        ,.S=BBM''d  rA   rc   r\   rZ   r   r  r)  rE  s    r?   	_dt_hourszArrowExtensionArray._dt_hours
  c    tDzzH "5577   XZZ  
 
 	
rA   c                     t          |           t          j        d |                                 D             t          j                                        S )Nc                <    g | ]}|t           ur|j        j        nd S r9   )r
   r  minutesr  s     r?   r?  z3ArrowExtensionArray._dt_minutes.<locals>.<listcomp>+
  s;        .0s]DBM))  rA   rc   r  rE  s    r?   _dt_minuteszArrowExtensionArray._dt_minutes'
  r  rA   c                     t          |           t          j        |                                 j        dt          j                                        S r  )r\   rZ   r   r  secondsr)  rE  s    r?   _dt_secondszArrowExtensionArray._dt_seconds3
  sL    tDzzH''))1t"(**  
 
 	
rA   c                     t          |           t          j        d |                                 D             t          j                                        S )Nc                <    g | ]}|t           ur|j        j        nd S r9   )r
   r  millisecondsr  s     r?   r?  z8ArrowExtensionArray._dt_milliseconds.<locals>.<listcomp>?
  s;        35C-IBM..T  rA   rc   r  rE  s    r?   _dt_millisecondsz$ArrowExtensionArray._dt_milliseconds;
  r  rA   c                     t          |           t          j        |                                 j        dt          j                                        S r  )r\   rZ   r   r  microsecondsr)  rE  s    r?   _dt_microsecondsz$ArrowExtensionArray._dt_microsecondsG
  sN    tDzzH''))6 XZZ  
 
 	
rA   c                     t          |           t          j        |                                 j        dt          j                                        S r  )r\   rZ   r   r  nanosecondsr)  rE  s    r?   _dt_nanosecondsz#ArrowExtensionArray._dt_nanosecondsQ
  sL    tDzzH''))54bhjj  
 
 	
rA   c                    | j                                         }| j        j        j        dk    rd |D             }t          j        |t                    S )Nr   c                >    g | ]}|d n|                                 S r9   )to_pytimedeltar=  tss     r?   r?  z:ArrowExtensionArray._dt_to_pytimedelta.<locals>.<listcomp>\
  s-    OOOBB?DDB,=,=,?,?OOOrA   r   )r   rv  r   r   r   r  r   r  r   rZ  s     r?   _dt_to_pytimedeltaz&ArrowExtensionArray._dt_to_pytimedeltaY
  sS    ~''));$)T1 	POO$OOODxF++++rA   c                     t          |           t          j        |                                                                 d                    S )NTr  )r\   rZ   r   r  total_secondsrE  s    r?   _dt_total_secondsz%ArrowExtensionArray._dt_total_seconds_
  sF    tDzzHT,,..<<>>DQQQ
 
 	
rA   r   c                   t           j                            | j        j                  rt          d          |                                 } t          |           t          j        |	                    |          d                    S )Nz&as_unit not implemented for date typesTr  )
rZ   r[   r   r   r   r   r  r\   r   r  )r   r   pd_arrays      r?   _dt_as_unitzArrowExtensionArray._dt_as_unitd
  ss    8DJ455 	P%&NOOO5577tDzz"(8#3#3D#9#9tLLLMMMrA   c                `     t          |           t          j        | j                            S r9   )r\   r:   yearr   rE  s    r?   _dt_yearzArrowExtensionArray._dt_yeark
  $    tDzz"'$.11222rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   dayr   rE  s    r?   _dt_dayzArrowExtensionArray._dt_dayo
  s$    tDzz"&00111rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   day_of_weekr   rE  s    r?   _dt_day_of_weekz#ArrowExtensionArray._dt_day_of_weeks
  $    tDzz".88999rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   day_of_yearr   rE  s    r?   _dt_day_of_yearz#ArrowExtensionArray._dt_day_of_yearz
  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   hourr   rE  s    r?   _dt_hourzArrowExtensionArray._dt_hour
  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   iso_calendarr   rE  s    r?   _dt_isocalendarz#ArrowExtensionArray._dt_isocalendar
  s$    tDzz"/$.99:::rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   is_leap_yearr   rE  s    r?   _dt_is_leap_yearz$ArrowExtensionArray._dt_is_leap_year
  s$    tDzz"/$.99:::rA   c                     t          |           t          j        t          j        | j                  d                    S Nrd   )r\   r:   r   r  r   rE  s    r?   _dt_is_month_startz&ArrowExtensionArray._dt_is_month_start
  s0    tDzz"(26$.#9#91==>>>rA   c           	         t          j        t          j        t          j        | j        d          t          j        | j        d                    d          } t          |           |          S )Nr  r  monthrd   r:   r   days_betweenfloor_temporalr   ceil_temporalr\   r   rr   s     r?   _dt_is_month_endz$ArrowExtensionArray._dt_is_month_end
  si    O!$.u=== g>>>  
 
 tDzz&!!!rA   c           
          t          |           t          j        t          j        t          j        | j                  d          t          j        t          j        | j                  d                              S r  r\   r:   rF   r   r  r   r  rE  s    r?   _dt_is_year_startz%ArrowExtensionArray._dt_is_year_start
  sa    tDzzG$.11155//33 
 
 	
rA   c           
          t          |           t          j        t          j        t          j        | j                  d          t          j        t          j        | j                  d                              S )N      r  rE  s    r?   _dt_is_year_endz#ArrowExtensionArray._dt_is_year_end
  sa    tDzzG$.11266//44 
 
 	
rA   c                    t          j        t          j        | j        d          t          j        | j        d                    } t	          |           |          S )Nquarterr  r  )r:   r   r  r   r\   r  s     r?   _dt_is_quarter_startz(ArrowExtensionArray._dt_is_quarter_start
  sU    dn9===dn5999
 
 tDzz&!!!rA   c           	         t          j        t          j        t          j        | j        d          t          j        | j        d                    d          } t          |           |          S )Nr  r  r  rd   r  r  s     r?   _dt_is_quarter_endz&ArrowExtensionArray._dt_is_quarter_end
  si    O!$.u=== i@@@  
 
 tDzz&!!!rA   c                    t          j        t          j        | j        d          t          j        | j        d                    } t          |           |          S )Nr  r  )r:   r  r  r   r  r\   r  s     r?   _dt_days_in_monthz%ArrowExtensionArray._dt_days_in_month
  sU    dn7;;;T^':::
 
 tDzz&!!!rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   microsecondr   rE  s    r?   _dt_microsecondz#ArrowExtensionArray._dt_microsecond
  r  rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   minuter   rE  s    r?   
_dt_minutezArrowExtensionArray._dt_minute
  $    tDzz")DN33444rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   r  r   rE  s    r?   	_dt_monthzArrowExtensionArray._dt_month
  s$    tDzz"(4>22333rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   
nanosecondr   rE  s    r?   _dt_nanosecondz"ArrowExtensionArray._dt_nanosecond
  s$    tDzz"-77888rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   r  r   rE  s    r?   _dt_quarterzArrowExtensionArray._dt_quarter
  s$    tDzz"*T^44555rA   c                `     t          |           t          j        | j                            S r9   )r\   r:   secondr   rE  s    r?   
_dt_secondzArrowExtensionArray._dt_second
  r  rA   c                     t          |           | j                            t          j                                        S r9   )r\   r   r   rZ   date32rE  s    r?   _dt_datezArrowExtensionArray._dt_date
  s.    tDzz$.--bikk::;;;rA   c                    | j         j        j        dv r| j         j        j        nd} t          |           | j                            t          j        |                              S )N>   r   r   r   )r   r   r   r\   r   r   rZ   time64)r   r   s     r?   _dt_timezArrowExtensionArray._dt_time
  s^     z',<DJ$)) 	
 tDzz$.--bioo>>???rA   c                H    t          j        | j        j        j                  S r9   )r   maybe_get_tzr   r   r   rE  s    r?   _dt_tzzArrowExtensionArray._dt_tz
  s    %dj&>&ABBBrA   c                $    | j         j        j        S r9   )r   r   r   rE  s    r?   _dt_unitzArrowExtensionArray._dt_unit
  s    z',,rA   c                d     t          |           t          j        | j        dd                    S )Nrd   r  )r\   r:   r  r   rE  s    r?   _dt_normalizez!ArrowExtensionArray._dt_normalize
  s)    tDzz"+DNAuEEFFFrA   formatc                d     t          |           t          j        | j        |                    S )N)r)  r\   r:   strftimer   )r   r)  s     r?   _dt_strftimez ArrowExtensionArray._dt_strftime
  s)    tDzz"+dnVDDDEEErA   r   !Literal['ceil', 'floor', 'round']	ambiguousr   nonexistentr   c                   |dk    rt          d          |dk    rt          d          t          |          }|t          d|           dddddddd	d
dddddd}|                    |j        d           }|t          d|d          |j        }t          t          | d          }	 t          |            |	| j	        ||                    S )Nr   zambiguous is not supported.znonexistent 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   zfreq= is not supported	_temporal)multipler   )
r   r0   r   r  _prefixr  r`  r:   r\   r   )
r   r  freqr/  r0  offsetpa_supported_unitr   r?  rounding_methods
             r?   _round_temporallyz%ArrowExtensionArray._round_temporally
  s$     	E%&CDDD'! 	G%&EFFF4 	HFFFGGG
 
  !$$V^T:: 	:88889998!"&:&:&:;;tDzz//$.8RVWWWXXXrA   c                2    |                      d|||          S )NceilrE  r   rA  r/  r0  s       r?   _dt_ceilzArrowExtensionArray._dt_ceil!  s     %%fdI{KKKrA   c                2    |                      d|||          S )Nrn   rH  rI  s       r?   	_dt_floorzArrowExtensionArray._dt_floor)       %%gtYLLLrA   c                2    |                      d|||          S )Nr  rH  rI  s       r?   	_dt_roundzArrowExtensionArray._dt_round1  rM  rA   localec                n    |d} t          |           t          j        | j        d|                    S )NCz%Ar)  rP  r+  r   rP  s     r?   _dt_day_namez ArrowExtensionArray._dt_day_name9  8     	FtDzz"+dnT&QQQRRRrA   c                n    |d} t          |           t          j        | j        d|                    S )NrR  z%BrS  r+  rT  s     r?   _dt_month_namez"ArrowExtensionArray._dt_month_name>  rV  rA   c                8   t           j                            | j        j                  rt          d| j        j         d          | j                                        }| j        j        j	        dk    rd |D             }t          j        |t                    S )Nz$to_pydatetime cannot be called with z) type. Convert to pyarrow timestamp type.r   c                B    g | ]}|d n|                     d          S )NF)warn)to_pydatetimer  s     r?   r?  z9ArrowExtensionArray._dt_to_pydatetime.<locals>.<listcomp>K  s2    XXXRBHDDB,<,<%,<,H,HXXXrA   r   )rZ   r[   r   r   r   r   r   rv  r   r   r  r   r  r  s     r?   _dt_to_pydatetimez%ArrowExtensionArray._dt_to_pydatetimeC  s    8DJ455 	5tz7O 5 5 5   ~''));$)T1 	YXXSWXXXDxF++++rA   c                   |dk    rt          d|d          dddd                    |d           }|t          d|d          |<| j                            t	          j        | j        j        j                            }n*t          j
        | j        t          |          ||          } t          |           |          S )	Nr   z
ambiguous=r=  earliestlatest)r   shift_backwardshift_forwardznonexistent=)r/  r0  )r   r  r   r   rZ   r   r   r   r   r:   assume_timezoner   r\   )r   r   r/  r0  nonexistent_parr   s         r?   _dt_tz_localizez#ArrowExtensionArray._dt_tz_localizeN  s      	H%&F&F&F&FGGG(%
 
 #
 
	 	  	J%&H&H&H&HIII 	^((dj6N6S)T)TUUFF'B9.  F tDzz&!!!rA   c                    | j         j        j        t          d          | j         j        j        }| j                            t          j        ||                    } t          |           |          S )Nz?Cannot convert tz-naive timestamps, use tz_localize to localize)
r   r   r   rC  r   r   r   rZ   r   r\   )r   r   current_unitrr   s       r?   _dt_tz_convertz"ArrowExtensionArray._dt_tz_convertg  sm    :#& 	Q   z/4$$R\,%C%CDDtDzz&!!!rA   )r   r   rV   r   )r   r   r   r   r9   )r   r   rV   r  )r   r   rV   r	  r  )r   r   r   r   rV   r   )r   r   )rV   r4  )NN)r   r;  r   r<  rV   r=  )rV   r   )rV   r   )rV   r   )rV   r1   )rV   r  )rV   r  )r  r   )r  r   r  r   r  r   rV   r=  )r  r   r  r   rV   r  )T)r  r   rV   r  )
r  r   r  r  r  r  r   r   rV   r   )NNNT)
r  r  r  r  r  r  r   r   rV   r   )r   r   rV   r  )rV   r  )r  r   rV   r  )r   )r  r  rV   r   )r_   N)r  r  r  r  r  r  rV   r  )FN)r  r   r  r   r  r   rV   r   )rV   r   )rV   r   )rV   r=  )r   r  r   r   r  r  rV   r=  )r  )r#  r$  rV   r  )r  r   rV   r   )r'  r   r  r   rV   rD  )r'  r   r  r   rV   r	  )r'  r   r  r   ro  r   )
r  r   r  r   r  r   r  r   r  r   )r  r  r  r   rV   r   )r  r   rV   r   )r  r   r  r  r   r   rV   r   )r  r  r_   r  ra   r  )r   r   r  r  r  r  )
r  r   r  r   rc  r  r  r  r  r  )r  r   rV   r  )r  r   r  r  )Tr   NT)r  r   r  r  r  r   )r  r  )r   Tr   T)r  r  r  r  r  r  r  r   r  r  r  r   )r  r  )Tr   N)r  r   r  r   r  r  r  r  )r  r   r  r  r  r  )r   N)rx   r   r/  r  r  r  )rr  r   )rr  r   r  r   )NNN)r/  r  r0  r  r1  r  )rO  r   )rY  )rZ  r   r   r   )r   T)r  r   r  r  r  r   )rq  )r  r   )rx   r   r/  r  )Nr   FN)r  r  r  r  r  r   r  r<  )Nr   )r  r  r  r  )r  r  )r  r  )r   r   )r)  r   )r   r   )r  r.  r/  r   r0  r   )r/  r   r0  r   )rP  r  )r^  
__module____qualname____doc____annotations__r   classmethodr   r  r  r  r   r3  r9  r  r@  rF  rI  rL  rO  rU  r[  rh  rv  rz  r}  r  propertyr   r  r  r  r  r   r  r  r  r  r  r  r   r  r  r   r'   r  r  r  r  r  r  r  r)  r  r  r  r  r  r	   r  r!  r+  r-  r3  rC  rN  rm  r  rq  ru  r  r  r  r  r  rz  r  r}  r~  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r  r   r$  r'  r*  r-  r0  r3  r6  r9  r=  rE  rI  rN  rT  rX  r]  rl  rp  r}  r  r  r  r  r  r  r  r  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-  rE  rJ  rL  rO  rU  rX  r]  re  rh  __classcell__)r  s   @r?   r   r      sc        ) )V 6 6 6 6 >BQV      [ /3%GE GE GE GE GE [GER 261 1 1 1 [1& % % % % [%N EJ^ ^ ^ ^ [^@Y Y Y Yv   (   
 AE* * * * *
9 
9 
9 
9= = = =* * * *: : : :
  
$ $ $ $+ + +41" 1" 1"fL L LK K K1 1 1 1    X % % % X%# # # #
/ 
/ 
/ 
/ 
/ 
/ - - - X-3 3 3 3 %) 8< 8< 8< 8< 8< 8<t %) 8< 8< 8< 8< 8< 8<z $!5 5 5 5 5 5&- - - - - - / / / / // / / / /
* 
* 
* 
*8 8 8 8 !:>
 
 
 
 
 
 
 
@ 	S	 ,0'+ +R +R +R +R +R +R  +RZ0 0 0 0+ + + +" 	S	!"" !%            #"  D
 
 
F F F F F0 	S	$%% *0%)	X X X X &%X8 !	ZB ZB ZB ZB ZBx  @ @ @ @	D 	D 	D 	D* * * * * *
 	S	 !! '+>	8 8 8 8 "!8t2 2 2 2 2 2 	S	"##6=> > > > $#>.% % % %.-E -E -E -E -E^    [, ,0;" ;" ;" ;" ;" ;" ;" ;"z <@ ~ ~ ~ ~ ~ ~ ~ ~B ,0%     B ,0%     ,    ,M M M Md > > > > > > > >F 
 
 
 
 
 
,%" %" %" %"N(' (' (' (' ('T  %I %I %I %IN )@ )@ )@ [)@V (D (D (D [(DZ7 7 7(= (= (= (= (= (=T
 
 
 
I I I I I NR" " " " "" " " " """ " " " "* " " " " "6I I I I PTD D D D D KO5 5 5 5 5" " " " ""7 7 7 74 4 4 4
4 4 4 4 UY	
 	
 	
 	
 	
< < << < <> > >< < << < <> > >< < << < << < <: : :9 9 99 9 9" " " "" " " "" " " "4 4 4 44 4 4
4 4 4 4 4
< < < < <4 4 4 4 42 2 2 2 2 4 4 4 4 4
4 4 4 4 4
4 4 4 4
4 4 4 4 4 !D D D D D"
 
 
 
 
4 4 4 4
4 4 4 4 
 
 X

 	
 	
 X	
 	
 	
 X	
 
 
 X
 	
 	
 X	
 
 
 X
 
 
 X
, , ,
 
 

N N N N 3 3 X3 2 2 X2 : : X: $M!K: : X: $M3 3 X3; ; ; ; ; X; ? ? X? " " X" 
 
 X
 
 
 X
 " " X" " " X" " " X" (O: : X: 5 5 X5 4 4 X4 9 9 X9 6 6 X6 5 5 X5 < < X< @ @ X@ C C XC - - X-G G GF F F F $+'.#Y #Y #Y #Y #YP $+'.	L L L L L $+'.	M M M M M $+'.	M M M M MS S S S S
S S S S S
	, 	, 	, $+'.	" " " " "2" " " " " " "rA   r   arraysSequence[ArrowExtensionArray]list[ArrowExtensionArray]c                   t          |           } t          | d                   t          |           c}t          j        |z                                |          j                                        }t          j        d | D                       	                    |          fdt          |          D             S )zTranspose 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   c                0    g | ]}|j         j        D ]}|S r:  )r   rB  )r=  r   r  s      r?   r?  z1transpose_homogeneous_pyarrow.<locals>.<listcomp>|  s*    VVVcAUVVEVVVVrA   c                \    g | ](}t                              |z                      )S r:  )r   r.  )r=  rb  r   ncolss     r?   r?  z1transpose_homogeneous_pyarrow.<locals>.<listcomp>~  s4    SSS		!e)U ; ;<<SSSrA   )r_  r&  r  r  r  TflattenrZ   r   r)  ri  )rt  nrowsr  r   rz  s      @@r?   transpose_homogeneous_pyarrowr~  q  s     &\\Fvay>>3v;;LE5i&&..ue<<>FFHHG

VVVVVV
W
WC
((7

CSSSSSeEllSSSSrA   )rR   rS   rT   rU   rV   rW   )r_   r`   ra   r`   rV   rS   )r   r   rV   r   )rt  ru  rV   rv  )
__future__r   r  rk  r  r  typingr   r   r   r   r   r  numpyr  pandas._libsr	   pandas._libs.tslibsr
   r   r   r   pandas.compatr   r   r   pandas.util._decoratorsr   pandas.util._validatorsr   pandas.core.dtypes.castr   r   pandas.core.dtypes.commonr   r   r   r   r   r   r   r   pandas.core.dtypes.dtypesr   pandas.core.dtypes.missingr   pandas.corer   r*  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commonr{  pandas.core.indexersr+   r,   r-   pandas.core.strings.baser.   pandas.io._utilr/   pandas.tseries.frequenciesr0   r"  rZ   pyarrow.computerv  r:   r1   r   rg   ri   greater
less_equalgreater_equalr]  r;   rC   rE   ro  rL   rN   rQ   rx  r^   rs   rw   r{   r   rp  r   r|  collections.abcr   pandas._typingr   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r   r2  r   r  r   r  r   r   r   r   r~  r:  rA   r?   <module>r     s   " " " " " "      				                                                
 ( ' ' ' ' ' : : : : : :       	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 	 6 5 5 5 5 5 + + + + + +            - , , , , , * * * * * * I I I I I I > > > > > >        6 5 5 5 5 5 2 2 2 2 2 2                           
 < ; ; ; ; ; 0 0 0 0 0 0 0 0 0 0 0 0 b      444444 hlgjm O 11|//v))  33~1122 & & & &    @r~11 	r" 	66	
 	r" 	66 	BB 	CC 	66 	77 	~ 	 	. 	> 	r  	33!&  =((((((                                     ( ::::::<<<<<<     ,A*" A*" A*" A*" A*" 	A*" A*" A*"HTT T T T T TrA   