Name	Size	Mode	Actions
benchmark.cpython-36.pyc	208	0644	editdlrm
cffi.cpython-36.pyc	1482	0644	editdlrm
compat.cpython-36.pyc	381	0644	editdlrm
compute.cpython-36.pyc	20263	0644	editdlrm
csv.cpython-36.pyc	382	0644	editdlrm
cuda.cpython-36.pyc	405	0644	editdlrm
dataset.cpython-36.pyc	27970	0644	editdlrm
feather.cpython-36.pyc	7739	0644	editdlrm
filesystem.cpython-36.pyc	14402	0644	editdlrm
flight.cpython-36.pyc	1353	0644	editdlrm
fs.cpython-36.pyc	10395	0644	editdlrm
hdfs.cpython-36.pyc	7055	0644	editdlrm
ipc.cpython-36.pyc	7394	0644	editdlrm
json.cpython-36.pyc	231	0644	editdlrm
jvm.cpython-36.pyc	8035	0644	editdlrm
orc.cpython-36.pyc	5140	0644	editdlrm
pandas_compat.cpython-36.pyc	27695	0644	editdlrm
parquet.cpython-36.pyc	66609	0644	editdlrm
plasma.cpython-36.pyc	4069	0644	editdlrm
serialization.cpython-36.pyc	13737	0644	editdlrm
types.cpython-36.pyc	12083	0644	editdlrm
util.cpython-36.pyc	4150	0644	editdlrm
_generated_version.cpython-36.pyc	223	0644	editdlrm
__init__.cpython-36.pyc	16476	0644	editdlrm

3 9%Eg5Y�@sdd
lm
Z
mZmZmZmZmZmZmZm Z m Z mZmZm Z mZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm 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/m0Z0m1Z1m2Z2m3Z3m4Z4
ddl5Z5ddl6m7Z7
ddl8Z8ddl9Z:dd�Z;dd�Zdd �Z?dd�Z@dd�ZAdd�ZBeB�
d:dd�
ZCdd�
dd�ZDdd�
dd�ZEdd�
dd�ZFdd�
dd �ZGdd�
d!d"�ZHdd�
d#d$�ZIdd�
d%d&�ZJd;ddd(�d)d*�ZKddd.�
d6d7�ZPd?dd.�
d8d9�ZQdS)@�)4�Function�FunctionOptions�FunctionRegistry�HashAggregateFunction�HashAggregateKernel�Kernel�ScalarAggregateFunction�ScalarAggregateKernel�ScalarFunction�ScalarKernel�VectorFunction�VectorKernel�ArraySortOptions�AssumeTimezoneOptions�CastOptions�CountOptions�DayOfWeekOptions�DictionaryEncodeOptions�ElementWiseAggregateOptions�ExtractRegexOptions� FilterOptions�IndexOptions�JoinOptions�MakeStructOptions�MatchSubstringOptions�ModeOptions�NullOptions� PadOptions�PartitionNthOptions�QuantileOptions�ReplaceSliceOptions�ReplaceSubstringOptions�RoundOptions�RoundToMultipleOptions�ScalarAggregateOptions�SelectKOptions�SetLookupOptions�SliceOptions�SortOptions�SplitOptions�SplitPatternOptions�StrftimeOptions�StrptimeOptions�TakeOptions�TDigestOptions�TrimOptions�VarianceOptions�WeekOptions� call_function�function_registry�get_function�list_functionsN)
�dedentc


Cs|jj
S)
N)�_doc� arg_names)
�func�r:�;/usr/local/lib64/python3.6/site-packages/pyarrow/compute.py�_get_arg_namesRs
r<cCs8
t|j
|jd
�|_|
|_|
|_g}|j}|j}|sR|jdkr@dnd}dj|j
|�}|j }t |�
} |jdj|�
�

|r�|jdj|�
�

|jd�

x2| D]*} |jdkr�d}nd}|jd j| |��

q�W|jd�

|dk �
r|jdj|j�
�

t j|�
}x*|jj�D]} |jdj| j
|j��

�q�Wdjdd�|D�
�
|_|S)N)�name�arity�
� arguments�argumentz,Call compute function {!r} with the given {}z {}. z{} z. Parameters ---------- �vector�scalar_aggregatez Array-likezArray-like or scalar-likezM {} : {} Argument to compute function z� memory_pool : pyarrow.MemoryPool, optional If not passed, will allocate memory from the default memory pool. z� options : pyarrow.compute.{0}, optional Parameters altering compute function semantics. z� {0} : optional Parameter for {1} constructor. Either `options` or `{0}` can be passed, but not both at the same time. �c
ss|]}
t|
�
V
qdS)
N)
r6)�.0�
sr:r:r;� �sz-_decorate_compute_function..)rBrC)�dictr=r>Z__arrow_compute_function__�__name__�__qualname__r7�summary�format�descriptionr<�append�kind�inspect� signature� parameters�values�join�__doc__)�wrapperZexposed_namer9�option_classZ doc_piecesZcpp_docrKZarg_strrMr8Zarg_nameZarg_type�options_sig�
pr:r:r;�_decorate_compute_functionVsH


















rZc
CsF|jj
}
|
sdSy t�|
Stk r@


tjd
j|
�
t�
dSXdS)Nz!Python binding for {} not exposed)r7Z options_class�globals�KeyError�warnings�warnrL�RuntimeWarning)r9� class_namer:r:r;�_get_options_class�s








racCsh|r$|dkr|
f|�
Std
j
|�
�
�
|dk rdt|t�r@|
f|�
St||
�rN|Stdj
||
t|�
��
�
|S)NzSFunction {!r} called with both an 'options' argument and additional named argumentsz-Function {!r} expected a {} parameter, got {})� TypeErrorrL� isinstancerH�type)r=rW�options�kwargsr:r:r;�_handle_options�s











rgcs8�dkrdd
�
�f
dd� }nddd���
�fdd� }|S)N)
�memory_poolc
s�j|
d|�S)
N)
�call)rh�args)
r9r:r;rV�s
z&_make_generic_wrapper..wrapper)rhrecst�
�|
|�}
�j
||
|�S)
N)rgri)rhrerjrf)r9� func_namerWr:r;rV�s


r:)rkr9rWrVr:)r9rkrWr;�_make_generic_wrapper�s

rlcCs�d
dlm
}
g}x|D]}|j|||j��

qWx|
D]}|j|||j��

q6W|j|d|jdd��

|dk r�|j|d|jdd��

tj|�
}x&|jj�D]}|j|j |jd�
�

q�Wtj |�
S)Nr
)
� Parameterrh)
�defaultre)
rO)rPrmrN�POSITIONAL_OR_KEYWORD�VAR_POSITIONAL�KEYWORD_ONLYrQrRrS�replace� Signature)r8� var_arg_namesrWrm�paramsr=rXrYr:r:r;�_make_signature�s













rvcCsdt|
�
}t
|
�
}|o |djd�
}|r8|j�jd�
g
}ng}t||
|�}t|||�|_t|||
|�S)Nr?�
*�����) rar<� startswith�pop�lstriprlrv� __signature__rZ)r=r9rWr8Z has_varargrtrVr:r:r;�_wrap_function�s







r}cCsht�}t
�}
d
dd�}xL|
j�D]@}|j||�}|
j|�
}||ksJt|�
�
t||�||<||<q WdS)z� Make global functions wrapping each compute function. Note that some of the automatically-generated wrappers may be overriden by custom versions below. �and_�or_)�and�orN)r[r3r5�getr4�AssertionErrorr})�
g�regZrewritesZcpp_namer=r9r:r:r;�_make_global_functions�s





r�TcCs8|
d
krtd�
�
|r t
j|
�
}n t
j|
�
}td|g
|�S)a� Cast array values to another data type. Can also be invoked as an array instance method. Parameters ---------- arr : Array or ChunkedArray target_type : DataType or type string alias Type to cast to safe : bool, default True Check for overflows or other unsafe conversions 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')) [ 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]') [ 1262304000000, 1420070400000 ] >>> arr.cast('timestamp[ms]').type TimestampType(timestamp[ms]) Returns ------- casted : Array Nz!Cast target type must not be None�cast)� ValueErrorr�safeZunsafer2)ZarrZtarget_typer�rer:r:r;r��s1



r�F)
�ignore_casec
Cstd
|g
t
|
|d��S)a�
Count the occurrences of substring *pattern* in each value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str pattern to search for exact matches ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �count_substring)
r�)r2r)�array�patternr�r:r:r;r�8
s

r�c
Cstd
|g
t
|
|d��S)a�
Count the non-overlapping matches of regex *pattern* in each value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str pattern to search for exact matches ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �count_substring_regex)
r�)r2r)r�r�r�r:r:r;r�N
s

r�c
Cstd
|g
t
|
|d��S)a�
Find the index of the first occurrence of substring *pattern* in each value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str pattern to search for exact matches ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �find_substring)
r�)r2r)r�r�r�r:r:r;r�d
s

r�c
Cstd
|g
t
|
|d��S)a�
Find the index of the first match of regex *pattern* in each value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str regex pattern to search for ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �find_substring_regex)
r�)r2r)r�r�r�r:r:r;r�z
s

r�c
Cstd
|g
t
|
|d��S)aa Test if the SQL-style LIKE pattern *pattern* matches a value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str SQL-style LIKE pattern. '%' will match any number of characters, '_' will match exactly one character, and all other characters match themselves. To match a literal percent sign or underscore, precede the character with a backslash. ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray � match_like)
r�)r2r)r�r�r�r:r:r;r��
s

r�c
Cstd
|g
t
|
|d��S)az
Test if substring *pattern* is contained within a value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str pattern to search for exact matches ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �match_substring)
r�)r2r)r�r�r�r:r:r;r��
s

r�c
Cstd
|g
t
|
|d��S)an
Test if regex *pattern* matches at any position a value of a string array. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray pattern : str regex pattern to search ignore_case : bool, default False Ignore case while searching. Returns ------- result : pyarrow.Array or pyarrow.ChunkedArray �match_substring_regex)
r�)r2r)r�r�r�r:r:r;r��
s

r�r?)� skip_nulls� min_countcCst|
||d
�}t
d|g
|�S)a  Return top-n most common values and number of times they occur in a passed numerical (chunked) array, in descending order of occurrence. If there are multiple values with same count, the smaller one is returned first. Parameters ---------- array : pyarrow.Array or pyarrow.ChunkedArray n : int, default 1 Specify the top-n values. skip_nulls : bool, default True If True, ignore nulls in the input. Else return an empty array if any input is null. min_count : int, default 0 If there are fewer than this many values in the input, return an empty array. Returns ------- An array of structs Examples -------- >>> import pyarrow as pa >>> import pyarrow.compute as pc >>> arr = pa.array([1, 1, 2, 2, 3, 2, 2, 2]) >>> modes = pc.mode(arr, 2) >>> modes[0] >>> modes[1] )r�r��mode)rr2)r��
nr�r�rer:r:r;r��
s!
r��dropcCst|�
}t
d
||
g|�S)a1 Select values (or records) from array- or table-like data given boolean filter, where true values are selected. Parameters ---------- data : Array, ChunkedArray, RecordBatch, or Table mask : Array, ChunkedArray Must be of boolean type null_selection_behavior : str, default 'drop' Configure the behavior on encountering a null slot in the mask. Allowed values are 'drop' and 'emit_null'. - 'drop': nulls will be treated as equivalent to False. - 'emit_null': nulls will result in a null in the output. Returns ------- result : depends on inputs Examples -------- >>> import pyarrow as pa >>> arr = pa.array(["a", "b", "c", None, "e"]) >>> mask = pa.array([True, False, None, False, True]) >>> arr.filter(mask) [ "a", "e" ] >>> arr.filter(mask, null_selection_behavior='emit_null') [ "a", null, "e" ] �filter)rr2)�data�maskZnull_selection_behaviorrer:r:r;r��
s(
r�)
rhc
Cs�|d
k r.|d
k r"|j|||�}qB|j|�
}n|d
k rB|jd|�}t
|
tj�s`tj|
|jd�}
n |j|
jkr�tj|
j�|jd�}
t|
d�
}td|g
||�}|d
k r�|j�dkr�tj|j�|tj �d�}|S)a�
Find the index of the first occurrence of a given value. Parameters ---------- data : Array or ChunkedArray value : Scalar-like object start : int, optional end : int, optional memory_pool : MemoryPool, optional If not passed, will allocate memory from the default memory pool. Returns ------- index : the index, or -1 if not found Nr
)
rd)
�value�index) �slicerc�pa�Scalar�scalarrd�as_pyrr2Zint64)r�r��start�endrhre�resultr:r:r;r�%s











r�)�boundscheckrhcCst|d
�
}t
d||
g||�S)as 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 Examples -------- >>> import pyarrow as pa >>> arr = pa.array(["a", "b", "c", None, "e", "f"]) >>> indices = pa.array([0, None, 4, 3]) >>> arr.take(indices) [ "a", null, "e", null ] )
r��take)r-r2)r��indicesr�rhrer:r:r;r�Is'
r�cCsVt|
t
jt
jt
jf�s(t
j|
|jd
�}
n |j|
jkrHt
j|
j�|jd
�}
td||
g�S)a[ Replace each null element in values with fill_value. The fill_value must be the same type as values or 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 data will attempt to cast. Returns ------- result : depends on inputs 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 0x7f95437f01a0> [ 1, 2, 5, 3 ] )
rdZcoalesce) rcr��Array�ChunkedArrayr�r�rdr�r2)rSZ fill_valuer:r:r;� fill_nullts "


r�c
CsR|d
krg}t|t
jt
jf�r*|jd�

ntdd�|�}t|
|�}td|g
||�S)a� 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. memory_pool : MemoryPool, optional If not passed, will allocate memory from the default memory pool. Returns ------- result : Array of indices 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) [ 5, 4, 2 ] N�dummy� descendingc

Ss|d
fS)Nr�r:)
�key_namer:r:r;��sz top_k_unstable..�select_k_unstable)r�r�)rcr�r�r�rN�mapr%r2)rS�
k� sort_keysrhrer:r:r;�top_k_unstable�s$




r�c
CsR|d
krg}t|t
jt
jf�r*|jd�

ntdd�|�}t|
|�}td|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. memory_pool : MemoryPool, optional If not passed, will allocate memory from the default memory pool. Returns ------- result : Array of indices 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) [ 0, 1, 2 ] Nr�� ascendingc

Ss|d
fS)Nr�r:)
r�r:r:r;r��sz#bottom_k_unstable..r�)r�r�)rcr�r�r�rNr�r%r2)rSr�r�rhrer:r:r;�bottom_k_unstable�s$




r�)
T)
r?)
r�)NN)
N)
N)RZpyarrow._computerrrrrrrr r rrr rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5rP�textwrapr6r]Zpyarrowr�r<rZrargrlrvr}r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r�r:r:r:r;�s8�9

@ :% ,$+*.