dangotbanned commented on code in PR #51680:
URL: https://github.com/apache/arrow/pull/51680#discussion_r4195755452
##########
python/pyarrow/_acero.pyi:
##########
@@ -0,0 +1,301 @@
+# This file was generated by stubgen-pyx v0.2.23 from python/pyarrow/_acero.pyx
+
+from pyarrow._compute import Expression
+from pyarrow.includes.common import *
+from pyarrow.includes.libarrow import *
+from pyarrow.includes.libarrow_acero import *
+from pyarrow.lib import *
+from pyarrow.lib import RecordBatchReader, Table
+
+
+class ExecNodeOptions(_Weakrefable):
+ """
+ Base class for the node options.
+
+ Use one of the subclasses to construct an options object.
+ """
+ __slots__ = ()
+
+class TableSourceNodeOptions(_TableSourceNodeOptions):
+ """
+ A Source node which accepts a table.
+
+ This is the option class for the "table_source" node factory.
+
+ Parameters
+ ----------
+ table : pyarrow.Table
+ The table which acts as the data source.
+ """
+ def __init__(self, table: Table): ...
+
+class RecordBatchReaderSourceNodeOptions(_RecordBatchReaderSourceNodeOptions):
+ """
+ A Source node which streams data from a RecordBatchReader.
+
+ This is the option class for the "record_batch_reader_source" node
+ factory.
+
+ Parameters
+ ----------
+ reader : pyarrow.RecordBatchReader
+ The reader which acts as the data source.
+ """
+ def __init__(self, reader: RecordBatchReader): ...
+
+class FilterNodeOptions(_FilterNodeOptions):
+ """
+ Make a node which excludes some rows from batches passed through it.
+
+ This is the option class for the "filter" node factory.
+
+ The "filter" operation provides an option to define data filtering
+ criteria. It selects rows where the given expression evaluates to true.
+ Filters can be written using pyarrow.compute.Expression, and the
+ expression must have a return type of boolean.
+
+ Parameters
+ ----------
+ filter_expression : pyarrow.compute.Expression
+ """
+ def __init__(self, filter_expression: Expression): ...
+
+class ProjectNodeOptions(_ProjectNodeOptions):
+ """
+ Make a node which executes expressions on input batches,
+ producing batches of the same length with new columns.
+
+ This is the option class for the "project" node factory.
+
+ The "project" operation rearranges, deletes, transforms, and
+ creates columns. Each output column is computed by evaluating
+ an expression against the source record batch. These must be
+ scalar expressions (expressions consisting of scalar literals,
+ field references and scalar functions, i.e. elementwise functions
+ that return one value for each input row independent of the value
+ of all other rows).
+
+ Parameters
+ ----------
+ expressions : list of pyarrow.compute.Expression
+ List of expressions to evaluate against the source batch. This must
+ be scalar expressions.
+ names : list of str, optional
+ List of names for each of the output columns (same length as
+ `expressions`). If `names` is not provided, the string
+ representations of exprs will be used.
+ """
+ def __init__(self, expressions, names=None): ...
+
+class AggregateNodeOptions(_AggregateNodeOptions):
+ """
+ Make a node which aggregates input batches, optionally grouped by keys.
+
+ This is the option class for the "aggregate" node factory.
+
+ Acero supports two types of aggregates: "scalar" aggregates,
+ and "hash" aggregates. Scalar aggregates reduce an array or scalar
+ input to a single scalar output (e.g. computing the mean of a column).
+ Hash aggregates act like GROUP BY in SQL and first partition data
+ based on one or more key columns, then reduce the data in each partition.
+ The aggregate node supports both types of computation, and can compute
+ any number of aggregations at once.
+
+ Parameters
+ ----------
+ aggregates : list of tuples
+ Aggregations which will be applied to the targeted fields.
+ Specified as a list of tuples, where each tuple is one aggregation
+ specification and consists of: aggregation target column(s) followed
+ by function name, aggregation function options object and the
+ output field name.
+ The target column(s) specification can be a single field reference,
+ an empty list or a list of fields unary, nullary and n-ary aggregation
+ functions respectively. Each field reference can be a string
+ column name or expression.
+ keys : list of field references, optional
+ Keys by which aggregations will be grouped. Each key can reference
+ a field using a string name or expression.
+ """
+ def __init__(self, aggregates, keys=None): ...
+
+class OrderByNodeOptions(_OrderByNodeOptions):
+ """
+ Make a node which applies a new ordering to the data.
+
+ Currently this node works by accumulating all data, sorting, and then
+ emitting the new data with an updated batch index.
+ Larger-than-memory sort is not currently supported.
+
+ This is the option class for the "order_by" node factory.
+
+ Parameters
+ ----------
+ sort_keys : sequence of (name, order, null_placement="at_end") tuples
+ Names of field/column keys to sort the input on,
+ along with the order each field/column is sorted in.
+ Each field reference can be a string column name or expression.
+ Accepted values for `order` are "ascending", "descending".
+ Accepted values for `null_placement` are "at_start", "at_end".
+ null_placement : str, optional
+ Where nulls in input should be sorted, only applying to
+ columns/fields mentioned in `sort_keys`.
+ Accepted values are "at_start", "at_end",
+ """
+ def __init__(self, sort_keys=(), *, null_placement=None): ...
+
+class HashJoinNodeOptions(_HashJoinNodeOptions):
+ """
+ Make a node which implements join operation using hash join strategy.
+
+ This is the option class for the "hashjoin" node factory.
+
+ Parameters
+ ----------
+ join_type : str
+ Type of join. One of "left semi", "right semi", "left anti",
+ "right anti", "inner", "left outer", "right outer", "full outer".
+ left_keys : str, Expression or list
+ Key fields from left input. Each key can be a string column name
+ or a field expression, or a list of such field references.
+ right_keys : str, Expression or list
+ Key fields from right input. See `left_keys` for details.
+ left_output : list, optional
+ List of output fields passed from left input. If left and right
+ output fields are not specified, all valid fields from both left and
+ right input will be output. Each field can be a string column name
+ or a field expression.
+ right_output : list, optional
+ List of output fields passed from right input. If left and right
+ output fields are not specified, all valid fields from both left and
+ right input will be output. Each field can be a string column name
+ or a field expression.
+ output_suffix_for_left : str
+ Suffix added to names of output fields coming from left input
+ (used to distinguish, if necessary, between fields of the same
+ name in left and right input and can be left empty if there are
+ no name collisions).
+ output_suffix_for_right : str
+ Suffix added to names of output fields coming from right input,
+ see `output_suffix_for_left` for details.
+ filter_expression : pyarrow.compute.Expression
+ Residual filter which is applied to matching row.
+ """
+ def __init__(self, join_type, left_keys, right_keys, left_output=None,
right_output=None, output_suffix_for_left='', output_suffix_for_right='',
filter_expression=None): ...
+
+class AsofJoinNodeOptions(_AsofJoinNodeOptions):
+ """
+ Make a node which implements 'as of join' operation.
+
+ This is the option class for the "asofjoin" node factory.
+
+ Parameters
+ ----------
+ left_on : str, Expression
+ The left key on which the join operation should be performed.
+ Can be a string column name or a field expression.
+
+ An inexact match is used on the "on" key, i.e. a row is considered a
+ match if and only if ``right.on - left.on`` is in the range
+ ``[min(0, tolerance), max(0, tolerance)]``.
+
+ The input dataset must be sorted by the "on" key. Must be a single
+ field of a common type.
+
+ Currently, the "on" key must be an integer, date, or timestamp type.
+ left_by: str, Expression or list
+ The left keys on which the join operation should be performed.
+ Exact equality is used for each field of the "by" keys.
+ Each key can be a string column name or a field expression,
+ or a list of such field references.
+ right_on : str, Expression
+ The right key on which the join operation should be performed.
+ See `left_on` for details.
+ right_by: str, Expression or list
+ The right keys on which the join operation should be performed.
+ See `left_by` for details.
+ tolerance : int
+ The tolerance to use for the asof join. The tolerance is interpreted in
+ the same units as the "on" key.
+ """
+ def __init__(self, left_on, left_by, right_on, right_by, tolerance): ...
+
+class Declaration(_Weakrefable):
+ """
+ Helper class for declaring the nodes of an ExecPlan.
+
+ A Declaration represents an unconstructed ExecNode, and potentially
+ more since its inputs may also be Declarations or when constructed
+ with ``from_sequence``.
+
+ The possible ExecNodes to use are registered with a name,
+ the "factory name", and need to be specified using this name, together
+ with its corresponding ExecNodeOptions subclass.
+
+ Parameters
+ ----------
+ factory_name : str
+ The ExecNode factory name, such as "table_source", "filter",
+ "project" etc. See the ExecNodeOptions subclasses for the exact
+ factory names to use.
+ options : ExecNodeOptions
+ Corresponding ExecNodeOptions subclass (matching the factory name).
+ inputs : list of Declaration, optional
+ Input nodes for this declaration. Optional if the node is a source
+ node, or when the declaration gets combined later with
+ ``from_sequence``.
+
+ Returns
+ -------
+ Declaration
+ """
+ def __init__(self, factory_name, options: ExecNodeOptions, inputs=None):
...
+ @staticmethod
+ def from_sequence(decls):
+ """
+ Convenience factory for the common case of a simple sequence of nodes.
+
+ Each of the declarations will be appended to the inputs of the
+ subsequent declaration, and the final modified declaration will
+ be returned.
+
+ Parameters
+ ----------
+ decls : list of Declaration
+
+ Returns
+ -------
+ Declaration
+ """
+ def __str__(self): ...
+ def __repr__(self): ...
+ def to_table(self, use_threads: bool=True):
+ """
Review Comment:
@jorisvandenbossche do you know why most functions/methods do not have a
return type?
I feel like maybe there's a configuration issue.
These should be:
```py
def __str__(self) -> str: ...
def __repr__(self) -> str: ...
def to_table(self, use_threads: bool=True) -> somewhere.Table:
```
Probably priority number 1 is fixing this
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
