§
    !P„jxa  ã                   ó‚  — d dl mZmZmZmZmZmZmZmZm	Z	m
Z
mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;m<Z<m=Z=m>Z>m?Z?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZP d dlQmRZR d dlSZSd dlTmUZU d dlVZVd dlWZXd dlWmYZY d dlZm[Z[ d„ Z\ eRdd	¦  «        Z]d
„ Z^d„ Z_d„ Z`d„ Zad„ Zbd„ Zcd„ Zdd„ Ze ee¦   «           ef¦   «         d         xZgZhd!d„Zid"ddœd„Zjdddœd„Zkd„ Zl	 d"ddœd„Zm	 d"ddœd„Znddddœd„Zod„ Zpd „ ZqdS )#é    )PÚFunctionÚFunctionOptionsÚFunctionRegistryÚHashAggregateFunctionÚHashAggregateKernelÚKernelÚScalarAggregateFunctionÚScalarAggregateKernelÚScalarFunctionÚScalarKernelÚVectorFunctionÚVectorKernelÚArraySortOptionsÚAssumeTimezoneOptionsÚCastOptionsÚCountOptionsÚCumulativeOptionsÚCumulativeSumOptionsÚDayOfWeekOptionsÚDictionaryEncodeOptionsÚRunEndEncodeOptionsÚElementWiseAggregateOptionsÚExtractRegexOptionsÚExtractRegexSpanOptionsÚFilterOptionsÚIndexOptionsÚInversePermutationOptionsÚJoinOptionsÚListSliceOptionsÚListFlattenOptionsÚMakeStructOptionsÚMapLookupOptionsÚMatchSubstringOptionsÚModeOptionsÚNullOptionsÚ
PadOptionsÚPairwiseOptionsÚPartitionNthOptionsÚPivotWiderOptionsÚQuantileOptionsÚRandomOptionsÚRankOptionsÚRankQuantileOptionsÚReplaceSliceOptionsÚReplaceSubstringOptionsÚRoundBinaryOptionsÚRoundOptionsÚRoundTemporalOptionsÚRoundToMultipleOptionsÚScalarAggregateOptionsÚScatterOptionsÚSelectKOptionsÚSetLookupOptionsÚSkewOptionsÚSliceOptionsÚSortOptionsÚSplitOptionsÚSplitPatternOptionsÚStrftimeOptionsÚStrptimeOptionsÚStructFieldOptionsÚTakeOptionsÚTDigestOptionsÚTrimOptionsÚUtf8NormalizeOptionsÚVarianceOptionsÚWeekOptionsÚWinsorizeOptionsÚZeroFillOptionsÚcall_functionÚfunction_registryÚget_functionÚlist_functionsÚcall_tabular_functionÚregister_scalar_functionÚregister_tabular_functionÚregister_aggregate_functionÚregister_vector_functionÚ
UdfContextÚ
Expression)Ú
namedtupleN)Údedent)Ú_compute_docstrings)Ú	docscrapec                 ó   — | j         j        S )N)Ú_docÚ	arg_names)Úfuncs    úT/root/disk_3tb/conda_envs/Huy-visual/lib/python3.11/site-packages/pyarrow/compute.pyÚ_get_arg_namesr\   s   s   € ØŒ9ÔÐó    Ú_OptionsClassDoc)Úparamsc                 óp   — | j         sd S t          j        | j         ¦  «        }t          |d         ¦  «        S )NÚ
Parameters)Ú__doc__rV   ÚNumpyDocStringr^   )Úoptions_classÚdocs     r[   Ú_scrape_options_class_docrf   z   s8   € ØÔ ð ØˆtÝ
Ô
" =Ô#8Ñ
9Ô
9€CÝ˜C Ô-Ñ.Ô.Ð.r]   c                 óª  — |j         }t          |j        |j        |j        |j        ¬¦  «        | _        || _        || _        g }|j	        }|s|j        dk    rdnd}d|j        ›d|› �}| 
                    |› d�¦  «         |j        }|r| 
                    |› d�¦  «         t          j                             |j        ¦  «        }	| 
                    t          d	¦  «        ¦  «         t!          |¦  «        }
|
D ]@}|j        d
v rd}nd}| 
                    |› d|› d�¦  «         | 
                    d¦  «         ŒA|��t%          |¦  «        }|rS|j        D ]J}| 
                    |j        › d|j        › d�¦  «         |j        D ]}| 
                    d|› d�¦  «         ŒŒKnŽt-          j        d|j        › d�t0          ¦  «         t3          j        |¦  «        }|j                             ¦   «         D ]=}| 
                    t          d|j        › d|j        › d|j        › d�¦  «        ¦  «         Œ>| 
                    t          d|j        › d�¦  «        ¦  «         | 
                    t          d¦  «        ¦  «         |	�;t          |	¦  «                             d¦  «        }| 
                    d|› d�¦  «         d                     |¦  «        | _        | S )N)ÚnameÚarityrd   Úoptions_requiredé   Ú	argumentsÚargumentzCall compute function z with the given z.

z

z.        Parameters
        ----------
        )ÚvectorÚscalar_aggregatez
Array-likezArray-like or scalar-likez : ú
z"    Argument to compute function.
z    zOptions class z does not have a docstringz                z. : optional
                    Parameter for z7 constructor. Either `options`
                    or `z@` can be passed, but not both at the same time.
                z&            options : pyarrow.compute.zK, optional
                Alternative way of passing options.
            z‰        memory_pool : pyarrow.MemoryPool, optional
            If not passed, will allocate memory from the default memory pool.
        Ú ) rX   Údictrh   ri   rd   rj   Ú__arrow_compute_function__Ú__name__Ú__qualname__ÚsummaryÚappendÚdescriptionrU   Úfunction_doc_additionsÚgetrT   r\   Úkindrf   r_   ÚtypeÚdescÚwarningsÚwarnÚRuntimeWarningÚinspectÚ	signatureÚ
parametersÚvaluesÚstripÚjoinrb   )ÚwrapperÚexposed_namerZ   rd   Úcpp_docÚ
doc_piecesrv   Úarg_strrx   Údoc_additionrY   Úarg_nameÚarg_typeÚoptions_class_docÚpÚsÚoptions_sigÚstrippeds                     r[   Ú_decorate_compute_functionr”   �   s°  € ð Œi€Gå)-ØŒYØŒjØÔ+Ø Ô1ð	*3ñ *3ô *3€GÔ&ð
 $€GÔØ'€GÔà€Jð Œo€GØð RØ!%¤¨a¢ �+�+°ZˆØQ¨4¬9ÐQÐQÈÐQÐQˆà×Ò˜Ð'Ð'Ð'Ñ(Ô(Ð(ð Ô%€KØð 0Ø×Ò˜[Ð.Ð.Ð.Ñ/Ô/Ð/å&Ô=×AÒAÀ$Ä)ÑLÔL€Lð ×Ò•fð ñ ô ñ ô ð õ ˜tÑ$Ô$€IØð Að AˆØŒ9Ð6Ð6Ð6Ø#ˆHˆHà2ˆHØ×Ò˜XÐ6Ð6¨(Ð6Ð6Ð6Ñ7Ô7Ð7Ø×ÒÐ?Ñ@Ô@Ð@Ð@ð Ñ Ý5°mÑDÔDÐØð 	Ø&Ô-ð 4ð 4�Ø×!Ò! Q¤VÐ":Ð":°´Ð":Ð":Ð":Ñ;Ô;Ð;Øœð 4ð 4�AØ×%Ò% l¨Q l l lÑ3Ô3Ð3Ð3ð4ð4õ
 ŒMð 7¨=Ô+Að 7ð 7ð 7Ý8FñHô Hð Hå!Ô+¨MÑ:Ô:ˆKØ Ô+×2Ò2Ñ4Ô4ð ð �Ø×!Ò!¥&ð *Ø”ð*ð *à#0Ô#9ð*ð *ð œð*ð *ð *ñ #ô #ñ ô ð ð ð
 	×Ò�&ð "Ø'4Ô'=ð"ð "ð "ñ ô ñ 	ô 	ð 	ð
 ×Ò•fð ñ ô ñ ô ð ð ÐÝ˜,Ñ'Ô'×-Ò-¨dÑ3Ô3ˆØ×ÒÐ+˜xÐ+Ð+Ð+Ñ,Ô,Ð,à—g’g˜jÑ)Ô)€G„OØ€Nr]   c                 óª   — | j         j        }|sd S 	 t          ¦   «         |         S # t          $ r" t	          j        d|› d�t          ¦  «         Y d S w xY w)NzPython binding for z not exposed)rX   rd   ÚglobalsÚKeyErrorr~   r   r€   )rZ   Ú
class_names     r[   Ú_get_options_classr™   Ô   st   € Ø”Ô(€JØð ØˆtðÝ‰yŒy˜Ô$Ð$øÝð ð ð ÝŒÐD¨JÐDÐDÐDÝ$ñ	&ô 	&ð 	&àˆtˆtðøøøs   ’& ¦(AÁAc           
      óô   — |s|r|�t          d| ›d�¦  «        ‚ ||i |¤ŽS |�Tt          |t          ¦  «        r |di |¤ŽS t          ||¦  «        r|S t          d| ›d|› dt          |¦  «        › �¦  «        ‚d S )Nz	Function z@ called with both an 'options' argument and additional argumentsz expected a z parameter, got © )Ú	TypeErrorÚ
isinstancerr   r|   )rh   rd   ÚoptionsÚargsÚkwargss        r[   Ú_handle_optionsr¡   à   sä   € Øð .ˆvð .ØÐÝð,˜Dð ,ð ,ð ,ñ-ô -ð -ð ˆ}˜dÐ- fÐ-Ð-Ð-àÐÝ�g�tÑ$Ô$ð 	Ø �=Ð+Ð+ 7Ð+Ð+Ð+Ý˜ Ñ/Ô/ð 	ØˆNÝð#˜ð #ð #¨Mð #ð #Ý˜‘=”=ð#ð #ñ$ô $ð 	$ð ˆ4r]   c                 ó@   ‡ ‡‡‡— ‰€d dœˆˆˆ fd„
}nd d dœˆˆˆ ˆfd„
}|S )N©Úmemory_poolc           	      ó2  •— ‰t           ur8t          |¦  «        ‰k    r%t          ‰› d‰› dt          |¦  «        › d�¦  «        ‚|r=t          |d         t          ¦  «        r"t	          j        ‰t          |¦  «        ¦  «        S ‰                     |d | ¦  «        S )Nú takes ú positional argument(s), but ú were givenr   )ÚEllipsisÚlenrœ   r�   rR   Ú_callÚlistÚcall)r¤   rŸ   ri   rZ   Ú	func_names     €€€r[   r‡   z&_make_generic_wrapper.<locals>.wrapperö   s¯   ø€ Ø�HÐ$Ð$­¨T©¬°eÒ);Ð);ÝØ ð 2ð 2¨ð 2ð 2Ý˜t™9œ9ð2ð 2ð 2ñô ð ð ð ?�
 4¨¤7­JÑ7Ô7ð ?Ý!Ô'¨	µ4¸±:´:Ñ>Ô>Ð>Ø—9’9˜T 4¨Ñ5Ô5Ð5r]   )r¤   rž   c           	      óˆ  •— ‰t           urMt          |¦  «        ‰k     r%t          ‰› d‰› dt          |¦  «        › d�¦  «        ‚|‰d …         }|d ‰…         }nd}t          ‰‰|||¦  «        }|r>t	          |d         t
          ¦  «        r#t          j        ‰t          |¦  «        |¦  «        S ‰                     ||| ¦  «        S )Nr¦   r§   r¨   r›   r   )	r©   rª   rœ   r¡   r�   rR   r«   r¬   r­   )	r¤   rž   rŸ   r    Úoption_argsri   rZ   r®   rd   s	        €€€€r[   r‡   z&_make_generic_wrapper.<locals>.wrapper   sï   ø€ Ø�HÐ$Ð$Ý�t‘9”9˜uÒ$Ð$Ý#Ø$ð 6ð 6¨Uð 6ð 6Ý" 4™yœyð6ð 6ð 6ñô ð ð # 5 6 6œl�Ø˜F˜U˜F”|��à �Ý% i°ÀØ&1°6ñ;ô ;ˆGàð H�
 4¨¤7­JÑ7Ô7ð HÝ!Ô'¨	µ4¸±:´:¸wÑGÔGÐGØ—9’9˜T 7¨KÑ8Ô8Ð8r]   r›   )r®   rZ   rd   ri   r‡   s   ```` r[   Ú_make_generic_wrapperr±   ô   s�   øøøø€ ØÐØ'+ð 	6ð 	6ð 	6ð 	6ð 	6ð 	6ð 	6ð 	6ð 	6ð 	6ð (,°Tð 	9ð 	9ð 	9ð 	9ð 	9ð 	9ð 	9ð 	9ð 	9ð 	9ð  €Nr]   c                 ól  — ddl m} g }| D ]&}|                      |||j        ¦  «        ¦  «         Œ'|D ]&}|                      |||j        ¦  «        ¦  «         Œ'|�Ÿt          j        |¦  «        }|j                             ¦   «         D ]K}|j        |j	        |j
        fv sJ ‚|r|                     |j
        ¬¦  «        }|                     |¦  «         ŒL|                      |d|j
        d ¬¦  «        ¦  «         |                      |d|j
        d ¬¦  «        ¦  «         t          j        |¦  «        S )Nr   )Ú	Parameter)r{   rž   )Údefaultr¤   )r�   r³   rw   ÚPOSITIONAL_ONLYÚVAR_POSITIONALr‚   rƒ   r„   r{   ÚPOSITIONAL_OR_KEYWORDÚKEYWORD_ONLYÚreplaceÚ	Signature)rY   Úvar_arg_namesrd   r³   r_   rh   r’   r�   s           r[   Ú_make_signaturer¼     sŠ  € Ø!Ð!Ð!Ð!Ð!Ð!Ø€FØð Bð BˆØ�Š�i�i  iÔ&?Ñ@Ô@ÑAÔAÐAÐAØð Að AˆØ�Š�i�i  iÔ&>Ñ?Ô?Ñ@Ô@Ð@Ð@ØÐ ÝÔ'¨Ñ6Ô6ˆØÔ'×.Ò.Ñ0Ô0ð 	ð 	ˆAØ”6˜iÔ=Ø'Ô4ð6ð 6ð 6ð 6ð 6àð ;à—I’I 9Ô#9�IÑ:Ô:�Ø�MŠM˜!ÑÔÐÐØ�Š�i�i 	¨9Ô+AØ(,ð.ñ .ô .ñ 	/ô 	/ð 	/à
‡M‚M�)�)˜M¨9Ô+AØ$(ð*ñ *ô *ñ +ô +ð +åÔ˜VÑ$Ô$Ð$r]   c                 óR  — t          |¦  «        }t          |¦  «        }|o|d                              d¦  «        }|r)|                     ¦   «                              d¦  «        g}ng }t          | |||j        ¬¦  «        }t          |||¦  «        |_        t          || ||¦  «        S )NéÿÿÿÿÚ*)ri   )
r™   r\   Ú
startswithÚpopÚlstripr±   ri   r¼   Ú__signature__r”   )rh   rZ   rd   rY   Ú
has_varargr»   r‡   s          r[   Ú_wrap_functionrÅ   *  s±   € Ý& tÑ,Ô,€MÝ˜tÑ$Ô$€IØÐ<˜y¨œ}×7Ò7¸Ñ<Ô<€JØð Ø"Ÿš™œ×/Ò/°Ñ4Ô4Ð5ˆˆàˆå#Øˆd�M¨¬ð5ñ 5ô 5€Gå+¨I°}Ø,9ñ;ô ;€GÔå% g¨t°T¸=ÑIÔIÐIr]   c                  ó^  — t          ¦   «         } t          ¦   «         }dddœ}|                     ¦   «         D ]v}|                     ||¦  «        }|                     |¦  «        }|j        dk    rŒ9|j        dk    r|j        dk    rŒP|| vs
J |¦   «         ‚t          ||¦  «        x| |<   | |<   ŒwdS )z«
    Make global functions wrapping each compute function.

    Note that some of the automatically-generated wrappers may be overridden
    by custom versions below.
    Úand_Úor_)ÚandÚorÚhash_aggregatero   r   N)r–   rI   rK   rz   rJ   r{   ri   rÅ   )ÚgÚregÚrewritesÚcpp_namerh   rZ   s         r[   Ú_make_global_functionsrÐ   :  sÚ   € õ 	‰	Œ	€AÝ
Ñ
Ô
€Cð Øðð €Hð ×&Ò&Ñ(Ô(ð ;ð ;ˆØ�|Š|˜H hÑ/Ô/ˆØ×Ò Ñ)Ô)ˆØŒ9Ð(Ò(Ð(ð ØŒ9Ð*Ò*Ð*¨t¬z¸Qª¨ð Ø˜1ˆ}ˆ}ˆ}˜d‰}Œ}ˆ}Ý .¨t°TÑ :Ô :Ð:ˆˆ(‰�a˜‘g�gð;ð ;r]   Úutf8_zero_fillc                 ó  — |dup|du}|r|�t          d¦  «        ‚|€Qt          j        j                             |¦  «        }|du rt          j        |¦  «        }nt          j        |¦  «        }t          d| g||¦  «        S )a†  
    Cast array values to another data type. Can also be invoked as an array
    instance method.

    Parameters
    ----------
    arr : Array-like
    target_type : DataType or str
        Type to cast to
    safe : bool, default True
        Check for overflows or other unsafe conversions
    options : CastOptions, default None
        Additional checks pass by CastOptions
    memory_pool : MemoryPool, optional
        memory pool to use for allocations during function execution.

    Examples
    --------
    >>> from datetime import datetime
    >>> import pyarrow as pa
    >>> arr = pa.array([datetime(2010, 1, 1), datetime(2015, 1, 1)])
    >>> arr.type
    TimestampType(timestamp[us])

    You can use ``pyarrow.DataType`` objects to specify the target type:

    >>> cast(arr, pa.timestamp('ms'))
    <pyarrow.lib.TimestampArray object at ...>
    [
      2010-01-01 00:00:00.000,
      2015-01-01 00:00:00.000
    ]

    >>> cast(arr, pa.timestamp('ms')).type
    TimestampType(timestamp[ms])

    Alternatively, it is also supported to use the string aliases for these
    types:

    >>> arr.cast('timestamp[ms]')
    <pyarrow.lib.TimestampArray object at ...>
    [
      2010-01-01 00:00:00.000,
      2015-01-01 00:00:00.000
    ]
    >>> arr.cast('timestamp[ms]').type
    TimestampType(timestamp[ms])

    Returns
    -------
    casted : Array
        The cast result as a new Array
    NzRMust either pass values for 'target_type' and 'safe' or pass a value for 'options'FÚcast)	Ú
ValueErrorÚpaÚtypesÚlibÚensure_typer   ÚunsafeÚsaferH   )ÚarrÚtarget_typerÚ   rž   r¤   Úsafe_vars_passeds         r[   rÓ   rÓ   \  s�   € ðl  DÐ(ÐF¨kÀÐ.EÐàð ;˜WÐ0Ýð :ñ ;ô ;ð 	;ð €Ý”h”l×.Ò.¨{Ñ;Ô;ˆØ�5ˆ=ˆ=Ý!Ô(¨Ñ5Ô5ˆGˆGå!Ô& {Ñ3Ô3ˆGÝ˜ # ¨°Ñ=Ô=Ð=r]   r£   c                óv  — |�2|�|                       |||z
  ¦  «        } n.|                       |¦  «        } n|�|                       d|¦  «        } t          |t          j        ¦  «        st          j        || j        ¬¦  «        }n=| j        |j        k    r-t          j        |                     ¦   «         | j        ¬¦  «        }t          |¬¦  «        }t          d| g||¦  «        }|�T|                     ¦   «         dk    r<t          j        |                     ¦   «         |z   t          j	        ¦   «         ¬¦  «        }|S )a  
    Find the index of the first occurrence of a given value.

    Parameters
    ----------
    data : Array-like
    value : Scalar-like object
        The value to search for.
    start : int, optional
    end : int, optional
    memory_pool : MemoryPool, optional
        If not passed, will allocate memory from the default memory pool.

    Returns
    -------
    index : int
        the index, or -1 if not found

    Examples
    --------
    >>> import pyarrow as pa
    >>> import pyarrow.compute as pc
    >>> arr = pa.array(["Lorem", "ipsum", "dolor", "sit", "Lorem", "ipsum"])
    >>> pc.index(arr, "ipsum")
    <pyarrow.Int64Scalar: 1>
    >>> pc.index(arr, "ipsum", start=2)
    <pyarrow.Int64Scalar: 5>
    >>> pc.index(arr, "amet")
    <pyarrow.Int64Scalar: -1>
    Nr   ©r|   ©ÚvalueÚindex)
Úslicer�   rÕ   ÚScalarÚscalarr|   Úas_pyr   rH   Úint64)Údatará   ÚstartÚendr¤   rž   Úresults          r[   râ   râ   ¡  s  € ð> ÐØˆ?Ø—:’:˜e S¨5¡[Ñ1Ô1ˆDˆDà—:’:˜eÑ$Ô$ˆDˆDØ	ˆØ�zŠz˜!˜SÑ!Ô!ˆå�e�RœYÑ'Ô'ð 9Ý”	˜% d¤iÐ0Ñ0Ô0ˆˆØ	Œ�e”jÒ	 Ð	 Ý”	˜%Ÿ+š+™-œ-¨d¬iÐ8Ñ8Ô8ˆÝ Ð'Ñ'Ô'€GÝ˜7 T F¨G°[ÑAÔA€FØÐ˜VŸ\š\™^œ^¨qÒ0Ð0Ý”˜6Ÿ<š<™>œ>¨EÑ1½¼¹
¼
ÐCÑCÔCˆØ€Mr]   T)Úboundscheckr¤   c                óJ   — t          |¬¦  «        }t          d| |g||¦  «        S )a–  
    Select values (or records) from array- or table-like data given integer
    selection indices.

    The result will be of the same type(s) as the input, with elements taken
    from the input array (or record batch / table fields) at the given
    indices. If an index is null then the corresponding value in the output
    will be null.

    Parameters
    ----------
    data : Array, ChunkedArray, RecordBatch, or Table
    indices : Array, ChunkedArray
        Must be of integer type
    boundscheck : boolean, default True
        Whether to boundscheck the indices. If False and there is an out of
        bounds index, will likely cause the process to crash.
    memory_pool : MemoryPool, optional
        If not passed, will allocate memory from the default memory pool.

    Returns
    -------
    result : depends on inputs
        Selected values for the given indices

    Examples
    --------
    >>> import pyarrow as pa
    >>> arr = pa.array(["a", "b", "c", None, "e", "f"])
    >>> indices = pa.array([0, None, 4, 3])
    >>> arr.take(indices)
    <pyarrow.lib.StringArray object at ...>
    [
      "a",
      null,
      "e",
      null
    ]
    )rì   Útake)r@   rH   )rè   Úindicesrì   r¤   rž   s        r[   rî   rî   Ó  s-   € õP  kÐ2Ñ2Ô2€GÝ˜ $¨ °'¸;ÑGÔGÐGr]   c                 ó:  — t          |t          j        t          j        t          j        f¦  «        st          j        || j        ¬¦  «        }n=| j        |j        k    r-t          j        |                     ¦   «         | j        ¬¦  «        }t          d| |g¦  «        S )ae  Replace each null element in values with a corresponding
    element from fill_value.

    If fill_value is scalar-like, then every null element in values
    will be replaced with fill_value. If fill_value is array-like,
    then the i-th element in values will be replaced with the i-th
    element in fill_value.

    The fill_value's type must be the same as that of values, or it
    must be able to be implicitly casted to the array's type.

    This is an alias for :func:`coalesce`.

    Parameters
    ----------
    values : Array, ChunkedArray, or Scalar-like object
        Each null element is replaced with the corresponding value
        from fill_value.
    fill_value : Array, ChunkedArray, or Scalar-like object
        If not same type as values, will attempt to cast.

    Returns
    -------
    result : depends on inputs
        Values with all null elements replaced

    Examples
    --------
    >>> import pyarrow as pa
    >>> arr = pa.array([1, 2, None, 3], type=pa.int8())
    >>> fill_value = pa.scalar(5, type=pa.int8())
    >>> arr.fill_null(fill_value)
    <pyarrow.lib.Int8Array object at ...>
    [
      1,
      2,
      5,
      3
    ]
    >>> arr = pa.array([1, 2, None, 4, None])
    >>> arr.fill_null(pa.array([10, 20, 30, 40, 50]))
    <pyarrow.lib.Int64Array object at ...>
    [
      1,
      2,
      30,
      4,
      50
    ]
    rß   Úcoalesce)	r�   rÕ   ÚArrayÚChunkedArrayrä   rå   r|   ræ   rH   )r„   Ú
fill_values     r[   Ú	fill_nullrõ   ÿ  sƒ   € õf �j¥2¤8­R¬_½b¼iÐ"HÑIÔIð EÝ”Y˜z°´Ð<Ñ<Ô<ˆ
ˆ
Ø	Œ˜
œÒ	'Ð	'Ý”Y˜z×/Ò/Ñ1Ô1¸¼ÐDÑDÔDˆ
å˜ f¨jÐ%9Ñ:Ô:Ð:r]   c                óü   — |€g }t          | t          j        t          j        f¦  «        r|                     d¦  «         nd„ t          ||¦  «        D ¦   «         }t          ||¦  «        }t          d| g||¦  «        S )ag  
    Select the indices of the top-k ordered elements from array- or table-like
    data.

    This is a specialization for :func:`select_k_unstable`. Output is not
    guaranteed to be stable.

    Parameters
    ----------
    values : Array, ChunkedArray, RecordBatch, or Table
        Data to sort and get top indices from.
    k : int
        The number of `k` elements to keep.
    sort_keys : List-like
        Column key names to order by when input is table-like data.
    null_placements : A list of "at_start" or "at_end"
        Whether nulls and NaNs are placed at the start or at the end.
        Accepted values are "at_end", "at_start".
    memory_pool : MemoryPool, optional
        If not passed, will allocate memory from the default memory pool.

    Returns
    -------
    result : Array
        Indices of the top-k ordered elements

    Examples
    --------
    >>> import pyarrow as pa
    >>> import pyarrow.compute as pc
    >>> arr = pa.array(["a", "b", "c", None, "e", "f"])
    >>> pc.top_k_unstable(arr, k=3)
    <pyarrow.lib.UInt64Array object at ...>
    [
      5,
      4,
      2
    ]
    N)ÚdummyÚ
descendingÚat_endc                 ó   — g | ]
\  }}|d |f‘ŒS )rø   r›   ©Ú.0Úsort_keyÚnull_placements      r[   ú
<listcomp>z"top_k_unstable.<locals>.<listcomp>h  s9   € ð Vð Vð VÙ1˜ >ð  ¨nÐ=ð Vð Vð Vr]   Úselect_k_unstable©r�   rÕ   rò   ró   rw   Úzipr6   rH   ©r„   ÚkÚ	sort_keysÚnull_placementsr¤   rž   s         r[   Útop_k_unstabler  :  s—   € ðR ÐØˆ	Ý�&�2œ8¥R¤_Ð5Ñ6Ô6ð VØ×ÒÐ:Ñ;Ô;Ð;Ð;ðVð VÝ58¸ÀOÑ5TÔ5TðVñ Vô Vˆ	å˜Q 	Ñ*Ô*€GÝÐ,¨v¨h¸ÀÑMÔMÐMr]   c                óü   — |€g }t          | t          j        t          j        f¦  «        r|                     d¦  «         nd„ t          ||¦  «        D ¦   «         }t          ||¦  «        }t          d| g||¦  «        S )a~  
    Select the indices of the bottom-k ordered elements from
    array- or table-like data.

    This is a specialization for :func:`select_k_unstable`. Output is not
    guaranteed to be stable.

    Parameters
    ----------
    values : Array, ChunkedArray, RecordBatch, or Table
        Data to sort and get bottom indices from.
    k : int
        The number of `k` elements to keep.
    sort_keys : List-like
        Column key names to order by when input is table-like data.
    null_placements : A list of "at_start" or "at_end"
        Whether nulls and NaNs are placed at the start or at the end.
        Accepted values are "at_end", "at_start".
    memory_pool : MemoryPool, optional
        If not passed, will allocate memory from the default memory pool.

    Returns
    -------
    result : Array of indices
        Indices of the bottom-k ordered elements

    Examples
    --------
    >>> import pyarrow as pa
    >>> import pyarrow.compute as pc
    >>> arr = pa.array(["a", "b", "c", None, "e", "f"])
    >>> pc.bottom_k_unstable(arr, k=3)
    <pyarrow.lib.UInt64Array object at ...>
    [
      0,
      1,
      2
    ]
    N)r÷   Ú	ascendingrù   c                 ó   — g | ]
\  }}|d |f‘ŒS )r	  r›   rû   s      r[   rÿ   z%bottom_k_unstable.<locals>.<listcomp>œ  s9   € ð Vð Vð VÙ1˜ >ð  ¨^Ð<ð Vð Vð Vr]   r   r  r  s         r[   Úbottom_k_unstabler  n  s™   € ðR ÐØˆ	Ý�&�2œ8¥R¤_Ð5Ñ6Ô6ð VØ×ÒÐ9Ñ:Ô:Ð:Ð:ðVð VÝ58¸ÀOÑ5TÔ5TðVñ Vô Vˆ	õ ˜Q 	Ñ*Ô*€GÝÐ,¨v¨h¸ÀÑMÔMÐMr]   Úsystem)Úinitializerrž   r¤   c                óJ   — t          |¬¦  «        }t          dg ||| ¬¦  «        S )aB  
    Generate numbers in the range [0, 1).

    Generated values are uniformly-distributed, double-precision
    in range [0, 1). Algorithm and seed can be changed via RandomOptions.

    Parameters
    ----------
    n : int
        Number of values to generate, must be greater than or equal to 0
    initializer : int or str
        How to initialize the underlying random generator.
        If an integer is given, it is used as a seed.
        If "system" is given, the random generator is initialized with
        a system-specific source of (hopefully true) randomness.
        Other values are invalid.
    options : pyarrow.compute.RandomOptions, optional
        Alternative way of passing options.
    memory_pool : pyarrow.MemoryPool, optional
        If not passed, will allocate memory from the default memory pool.
    )r  Úrandom)Úlength)r+   rH   )Únr  rž   r¤   s       r[   r  r  £  s-   € õ, ¨Ð4Ñ4Ô4€GÝ˜ 2 w°ÀAÐFÑFÔFÐFr]   c                  ó€  — t          | ¦  «        }|dk    r–t          | d         t          t          f¦  «        rt	          j        | d         ¦  «        S t          | d         t          ¦  «        rt	          j        | d         ¦  «        S t          dt          | d         ¦  «        › �¦  «        ‚t	          j        | ¦  «        S )a  Reference a column of the dataset.

    Stores only the field's name. Type and other information is known only when
    the expression is bound to a dataset having an explicit scheme.

    Nested references are allowed by passing multiple names or a tuple of
    names. For example ``('foo', 'bar')`` references the field named "bar"
    inside the field named "foo".

    Parameters
    ----------
    *name_or_index : string, multiple strings, tuple or int
        The name or index of the (possibly nested) field the expression
        references to.

    Returns
    -------
    field_expr : Expression
        Reference to the given field

    Examples
    --------
    >>> import pyarrow.compute as pc
    >>> pc.field("a")
    <pyarrow.compute.Expression a>
    >>> pc.field(1)
    <pyarrow.compute.Expression FieldPath(1)>
    >>> pc.field(("a", "b"))
    <pyarrow.compute.Expression FieldRef.Nested(FieldRef.Name(a) ...
    >>> pc.field("a", "b")
    <pyarrow.compute.Expression FieldRef.Nested(FieldRef.Name(a) ...
    rk   r   zCfield reference should be str, multiple str, tuple or integer, got )
rª   r�   ÚstrÚintrR   Ú_fieldÚtupleÚ_nested_fieldrœ   r|   )Úname_or_indexr  s     r[   Úfieldr  ½  s½   € õB 	ˆMÑÔ€AØˆA‚v€vÝ�m AÔ&­­c¨
Ñ3Ô3ð 	ÝÔ$ ]°1Ô%5Ñ6Ô6Ð6Ý˜ aÔ(­%Ñ0Ô0ð 	ÝÔ+¨M¸!Ô,<Ñ=Ô=Ð=åð9Ý $ ]°1Ô%5Ñ 6Ô 6ð9ð 9ñô ð õ Ô'¨Ñ6Ô6Ð6r]   c                 ó*   — t          j        | ¦  «        S )a‡  Expression representing a scalar value.

    Creates an Expression object representing a scalar value that can be used
    in compute expressions and predicates.

    Parameters
    ----------
    value : bool, int, float or string
        Python value of the scalar. This function accepts any value that can be
        converted to a ``pyarrow.Scalar`` using ``pa.scalar()``.

    Notes
    -----
    This function differs from ``pyarrow.scalar()`` in the following way:

    * ``pyarrow.scalar()`` creates a ``pyarrow.Scalar`` object that represents
      a single value in Arrow's memory model.
    * ``pyarrow.compute.scalar()`` creates an ``Expression`` object representing
      a scalar value that can be used in compute expressions, predicates, and
      dataset filtering operations.

    Returns
    -------
    scalar_expr : Expression
        An Expression representing the scalar value
    )rR   Ú_scalarrà   s    r[   rå   rå   î  s   € õ6 Ô˜eÑ$Ô$Ð$r]   )NNNN)NN)rÚpyarrow._computer   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%   r&   r'   r(   r)   r*   r+   r,   r-   r.   r/   r0   r1   r2   r3   r4   r5   r6   r7   r8   r9   r:   r;   r<   r=   r>   r?   r@   rA   rB   rC   rD   rE   rF   rG   rH   rI   rJ   rK   rL   rM   rN   rO   rP   rQ   rR   ÚcollectionsrS   r�   ÚtextwraprT   r~   ÚpyarrowrÕ   rU   Úpyarrow.vendoredrV   r\   r^   rf   r”   r™   r¡   r±   r¼   rÅ   rÐ   r–   Ú
utf8_zfillrÑ   rÓ   râ   rî   rõ   r  r  r  r  rå   r›   r]   r[   ú<module>r"     s*  ðð$Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uð Uðn #Ð "Ð "Ð "Ð "Ð "Ø €€€Ø Ð Ð Ð Ð Ð Ø €€€à Ð Ð Ð Ø 'Ð 'Ð 'Ð 'Ð 'Ð 'Ø &Ð &Ð &Ð &Ð &Ð &ðð ð ð �:Ð0°+Ñ>Ô>Ð ð/ð /ð /ðPð Pð Pðf	ð 	ð 	ðð ð ð(ð ð ð>%ð %ð %ð.Jð Jð Jð ;ð ;ð ;ð: Ð Ñ Ô Ð à%˜g™iœiÐ(8Ô9Ð 9€
ˆ^ðB>ð B>ð B>ð B>ðJ/¸Dð /ð /ð /ð /ð /ðd (,¸ð )Hð )Hð )Hð )Hð )HðX8;ð 8;ð 8;ðx 48ð1NØHLð1Nð 1Nð 1Nð 1Nð 1Nðj 48ð2NØHLð2Nð 2Nð 2Nð 2Nð 2Nðj &¨tÀð Gð Gð Gð Gð Gð4.7ð .7ð .7ðb%ð %ð %ð %ð %r]   