kenilkb/DriverTrac
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
DriverTrac/venv/lib/python3.12/site-packages/polars/_plr.pyi
Kenil_KB 1ceb3aae28 POC_DEMO
2025-11-28 09:08:33 +05:30

2523 lines
92 KiB
Python
Raw Permalink Blame History

from collections.abc import Callable, Sequence
from typing import Any, Literal, overload
from numpy.typing import NDArray
from typing_extensions import TypeAlias
from polars.io.scan_options._options import ScanOptions
# This file mirrors all the definitions made in the polars-python Rust API.
__version__: str
__build__: Any
_ir_nodes: Any
_allocator: Any
_debug: bool
RUNTIME_REPR: str
CompatLevel: TypeAlias = int | bool
BufferInfo: TypeAlias = tuple[int, int, int]
UnicodeForm: TypeAlias = Literal["NFC", "NFKC", "NFD", "NFKD"]
KeyValueMetadata: TypeAlias = Sequence[tuple[str, str]] | Any
TimeZone: TypeAlias = str | None
UpcastOrForbid: TypeAlias = Literal["upcast", "forbid"]
ExtraColumnsPolicy: TypeAlias = Literal["ignore", "raise"]
MissingColumnsPolicy: TypeAlias = Literal["insert", "raise"]
MissingColumnsPolicyOrExpr: TypeAlias = Literal["insert", "raise"] | Any
ColumnMapping: TypeAlias = Any
DeletionFilesList: TypeAlias = Any
DefaultFieldValues: TypeAlias = Any
Path: TypeAlias = str | Any
Schema: TypeAlias = Any
NullValues: TypeAlias = Any
DataType: TypeAlias = Any
SyncOnCloseType: TypeAlias = Literal["none", "data", "all"]
SinkOptions: TypeAlias = dict[str, Any]
SinkTarget: TypeAlias = str | Any | PyPartitioning
AsofStrategy: TypeAlias = Literal["backward", "forward", "nearest"]
InterpolationMethod: TypeAlias = Literal["linear", "nearest"]
AvroCompression: TypeAlias = Literal["uncompressed", "snappy", "deflate"]
CategoricalOrdering: TypeAlias = Literal["physical", "lexical"]
StartBy: TypeAlias = Literal[
"window",
"datapoint",
"monday",
"tuesday",
"wednesday",
"thursday",
"friday",
"saturday",
"sunday",
]
ClosedWindow: TypeAlias = Literal["left", "right", "both", "none"]
RoundMode: TypeAlias = Literal["half_to_even", "half_away_from_zero"]
CsvEncoding: TypeAlias = Literal["utf8", "utf8-lossy"]
IpcCompression: TypeAlias = Literal["uncompressed", "lz4", "zstd"]
JoinType: TypeAlias = Literal["inner", "left", "right", "full", "semi", "anti", "cross"]
Label: TypeAlias = Literal["left", "right", "datapoint"]
ListToStructWidthStrategy: TypeAlias = Literal["first_non_null", "max_width"]
NonExistent: TypeAlias = Literal["null", "raise"]
NullBehavior: TypeAlias = Literal["drop", "ignore"]
NullStrategy: TypeAlias = Literal["ignore", "propagate"]
ParallelStrategy: TypeAlias = Literal[
"auto", "columns", "row_groups", "prefiltered", "none"
]
IndexOrder: TypeAlias = Literal["fortran", "c"]
QuantileMethod: TypeAlias = Literal[
"lower", "higher", "nearest", "linear", "midpoint", "equiprobable"
]
RankMethod: TypeAlias = Literal["min", "max", "average", "dense", "ordinal", "random"]
Roll: TypeAlias = Literal["raise", "forward", "backward"]
TimeUnit: TypeAlias = Literal["ns", "us", "ms"]
UniqueKeepStrategy: TypeAlias = Literal["first", "last", "any", "none"]
SearchSortedSide: TypeAlias = Literal["any", "left", "right"]
ClosedInterval: TypeAlias = Literal["both", "left", "right", "none"]
WindowMapping: TypeAlias = Literal["group_to_rows", "join", "explode"]
JoinValidation: TypeAlias = Literal["m:m", "m:1", "1:m", "1:1"]
MaintainOrderJoin: TypeAlias = Literal[
"none", "left", "right", "left_right", "right_left"
]
QuoteStyle: TypeAlias = Literal["always", "necessary", "non_numeric", "never"]
SetOperation: TypeAlias = Literal[
"union", "difference", "intersection", "symmetric_difference"
]
FloatFmt: TypeAlias = Literal["full", "mixed"]
NDArray1D: TypeAlias = NDArray[Any]
ParquetFieldOverwrites: TypeAlias = Any
StatisticsOptions: TypeAlias = Any
EngineType: TypeAlias = Literal["auto", "in-memory", "streaming", "gpu"]
PyScanOptions: TypeAlias = Any
# exceptions
class PolarsError(Exception): ...
class ColumnNotFoundError(PolarsError): ...
class ComputeError(PolarsError): ...
class DuplicateError(PolarsError): ...
class InvalidOperationError(PolarsError): ...
class NoDataError(PolarsError): ...
class OutOfBoundsError(PolarsError): ...
class SQLInterfaceError(PolarsError): ...
class SQLSyntaxError(PolarsError): ...
class SchemaError(PolarsError): ...
class SchemaFieldNotFoundError(PolarsError): ...
class ShapeError(PolarsError): ...
class StringCacheMismatchError(PolarsError): ...
class StructFieldNotFoundError(PolarsError): ...
class PolarsWarning(Warning): ...
class PerformanceWarning(PolarsWarning): ...
class CategoricalRemappingWarning(PerformanceWarning): ...
class MapWithoutReturnDtypeWarning(PolarsWarning): ...
class PanicException(PolarsError): ...
class PySeries:
# map
def map_elements(
self, function: Any, return_dtype: Any | None, skip_nulls: bool
) -> PySeries: ...
# general
def struct_unnest(self) -> PyDataFrame: ...
def struct_fields(self) -> list[str]: ...
def is_sorted_ascending_flag(self) -> bool: ...
def is_sorted_descending_flag(self) -> bool: ...
def can_fast_explode_flag(self) -> bool: ...
def cat_uses_lexical_ordering(self) -> bool: ...
def cat_is_local(self) -> bool: ...
def cat_to_local(self) -> PySeries: ...
def estimated_size(self) -> int: ...
def get_object(self, index: int) -> Any: ...
def reshape(self, dims: Sequence[int]) -> PySeries: ...
def get_fmt(self, index: int, str_len_limit: int) -> str: ...
def rechunk(self, in_place: bool) -> PySeries | None: ...
def get_index(self, index: int) -> Any: ...
def get_index_signed(self, index: int) -> Any: ...
def bitand(self, other: PySeries) -> PySeries: ...
def bitor(self, other: PySeries) -> PySeries: ...
def bitxor(self, other: PySeries) -> PySeries: ...
def chunk_lengths(self) -> list[int]: ...
def name(self) -> str: ...
def rename(self, name: str) -> None: ...
def dtype(self) -> Any: ...
def set_sorted_flag(self, descending: bool) -> PySeries: ...
def n_chunks(self) -> int: ...
def append(self, other: PySeries) -> None: ...
def extend(self, other: PySeries) -> None: ...
def new_from_index(self, index: int, length: int) -> PySeries: ...
def filter(self, filter: PySeries) -> PySeries: ...
def sort(
self, descending: bool, nulls_last: bool, multithreaded: bool
) -> PySeries: ...
def gather_with_series(self, indices: PySeries) -> PySeries: ...
def null_count(self) -> int: ...
def has_nulls(self) -> bool: ...
def equals(
self, other: PySeries, check_dtypes: bool, check_names: bool, null_equal: bool
) -> bool: ...
def as_str(self) -> str: ...
def len(self) -> int: ...
def as_single_ptr(self) -> int: ...
def clone(self) -> PySeries: ...
def zip_with(self, mask: PySeries, other: PySeries) -> PySeries: ...
def to_dummies(
self, separator: str | None, drop_first: bool, drop_nulls: bool
) -> PyDataFrame: ...
def get_list(self, index: int) -> PySeries | None: ...
def n_unique(self) -> int: ...
def floor(self) -> PySeries: ...
def shrink_to_fit(self) -> None: ...
def dot(self, other: PySeries) -> Any: ...
def __getstate__(self) -> bytes: ...
def __setstate__(self, state: bytes) -> None: ...
def skew(self, bias: bool) -> float | None: ...
def kurtosis(self, fisher: bool, bias: bool) -> float | None: ...
def cast(self, dtype: Any, strict: bool, wrap_numerical: bool) -> PySeries: ...
def get_chunks(self) -> list[Any]: ...
def is_sorted(self, descending: bool, nulls_last: bool) -> bool: ...
def clear(self) -> PySeries: ...
def head(self, n: int) -> PySeries: ...
def tail(self, n: int) -> PySeries: ...
def value_counts(
self, sort: bool, parallel: bool, name: str, normalize: bool
) -> PyDataFrame: ...
def slice(self, offset: int, length: int | None) -> PySeries: ...
def not_(self) -> PySeries: ...
def shrink_dtype(self) -> PySeries: ...
def str_to_datetime_infer(
self,
time_unit: TimeUnit | None,
strict: bool,
exact: bool,
ambiguous: PySeries,
) -> PySeries: ...
def str_to_decimal_infer(self, inference_length: int) -> PySeries: ...
def list_to_struct(
self, width_strat: ListToStructWidthStrategy, name_gen: Any | None
) -> PySeries: ...
def str_json_decode(self, infer_schema_length: int | None) -> PySeries: ...
# aggregations
def any(self, ignore_nulls: bool) -> bool | None: ...
def all(self, ignore_nulls: bool) -> bool | None: ...
def arg_max(self) -> int | None: ...
def arg_min(self) -> int | None: ...
def min(self) -> Any: ...
def max(self) -> Any: ...
def mean(self) -> Any: ...
def median(self) -> Any: ...
def product(self) -> Any: ...
def quantile(self, quantile: float, interpolation: QuantileMethod) -> Any: ...
def std(self, ddof: int) -> Any: ...
def var(self, ddof: int) -> Any: ...
def sum(self) -> Any: ...
def first(self) -> Any: ...
def last(self) -> Any: ...
def approx_n_unique(self) -> int: ...
def bitwise_and(self) -> Any: ...
def bitwise_or(self) -> Any: ...
def bitwise_xor(self) -> Any: ...
# arithmetic
# Operations with another PySeries
def add(self, other: PySeries) -> PySeries: ...
def sub(self, other: PySeries) -> PySeries: ...
def mul(self, other: PySeries) -> PySeries: ...
def div(self, other: PySeries) -> PySeries: ...
def rem(self, other: PySeries) -> PySeries: ...
# Operations with integer/float/datetime/duration scalars
def add_u8(self, other: int) -> PySeries: ...
def add_u16(self, other: int) -> PySeries: ...
def add_u32(self, other: int) -> PySeries: ...
def add_u64(self, other: int) -> PySeries: ...
def add_i8(self, other: int) -> PySeries: ...
def add_i16(self, other: int) -> PySeries: ...
def add_i32(self, other: int) -> PySeries: ...
def add_i64(self, other: int) -> PySeries: ...
def add_datetime(self, other: int) -> PySeries: ...
def add_duration(self, other: int) -> PySeries: ...
def add_f32(self, other: float) -> PySeries: ...
def add_f64(self, other: float) -> PySeries: ...
def sub_u8(self, other: int) -> PySeries: ...
def sub_u16(self, other: int) -> PySeries: ...
def sub_u32(self, other: int) -> PySeries: ...
def sub_u64(self, other: int) -> PySeries: ...
def sub_i8(self, other: int) -> PySeries: ...
def sub_i16(self, other: int) -> PySeries: ...
def sub_i32(self, other: int) -> PySeries: ...
def sub_i64(self, other: int) -> PySeries: ...
def sub_datetime(self, other: int) -> PySeries: ...
def sub_duration(self, other: int) -> PySeries: ...
def sub_f32(self, other: float) -> PySeries: ...
def sub_f64(self, other: float) -> PySeries: ...
def div_u8(self, other: int) -> PySeries: ...
def div_u16(self, other: int) -> PySeries: ...
def div_u32(self, other: int) -> PySeries: ...
def div_u64(self, other: int) -> PySeries: ...
def div_i8(self, other: int) -> PySeries: ...
def div_i16(self, other: int) -> PySeries: ...
def div_i32(self, other: int) -> PySeries: ...
def div_i64(self, other: int) -> PySeries: ...
def div_f32(self, other: float) -> PySeries: ...
def div_f64(self, other: float) -> PySeries: ...
def mul_u8(self, other: int) -> PySeries: ...
def mul_u16(self, other: int) -> PySeries: ...
def mul_u32(self, other: int) -> PySeries: ...
def mul_u64(self, other: int) -> PySeries: ...
def mul_i8(self, other: int) -> PySeries: ...
def mul_i16(self, other: int) -> PySeries: ...
def mul_i32(self, other: int) -> PySeries: ...
def mul_i64(self, other: int) -> PySeries: ...
def mul_f32(self, other: float) -> PySeries: ...
def mul_f64(self, other: float) -> PySeries: ...
def rem_u8(self, other: int) -> PySeries: ...
def rem_u16(self, other: int) -> PySeries: ...
def rem_u32(self, other: int) -> PySeries: ...
def rem_u64(self, other: int) -> PySeries: ...
def rem_i8(self, other: int) -> PySeries: ...
def rem_i16(self, other: int) -> PySeries: ...
def rem_i32(self, other: int) -> PySeries: ...
def rem_i64(self, other: int) -> PySeries: ...
def rem_f32(self, other: float) -> PySeries: ...
def rem_f64(self, other: float) -> PySeries: ...
# Reverse operations (rhs)
def add_u8_rhs(self, other: int) -> PySeries: ...
def add_u16_rhs(self, other: int) -> PySeries: ...
def add_u32_rhs(self, other: int) -> PySeries: ...
def add_u64_rhs(self, other: int) -> PySeries: ...
def add_i8_rhs(self, other: int) -> PySeries: ...
def add_i16_rhs(self, other: int) -> PySeries: ...
def add_i32_rhs(self, other: int) -> PySeries: ...
def add_i64_rhs(self, other: int) -> PySeries: ...
def add_f32_rhs(self, other: float) -> PySeries: ...
def add_f64_rhs(self, other: float) -> PySeries: ...
def sub_u8_rhs(self, other: int) -> PySeries: ...
def sub_u16_rhs(self, other: int) -> PySeries: ...
def sub_u32_rhs(self, other: int) -> PySeries: ...
def sub_u64_rhs(self, other: int) -> PySeries: ...
def sub_i8_rhs(self, other: int) -> PySeries: ...
def sub_i16_rhs(self, other: int) -> PySeries: ...
def sub_i32_rhs(self, other: int) -> PySeries: ...
def sub_i64_rhs(self, other: int) -> PySeries: ...
def sub_f32_rhs(self, other: float) -> PySeries: ...
def sub_f64_rhs(self, other: float) -> PySeries: ...
def div_u8_rhs(self, other: int) -> PySeries: ...
def div_u16_rhs(self, other: int) -> PySeries: ...
def div_u32_rhs(self, other: int) -> PySeries: ...
def div_u64_rhs(self, other: int) -> PySeries: ...
def div_i8_rhs(self, other: int) -> PySeries: ...
def div_i16_rhs(self, other: int) -> PySeries: ...
def div_i32_rhs(self, other: int) -> PySeries: ...
def div_i64_rhs(self, other: int) -> PySeries: ...
def div_f32_rhs(self, other: float) -> PySeries: ...
def div_f64_rhs(self, other: float) -> PySeries: ...
def mul_u8_rhs(self, other: int) -> PySeries: ...
def mul_u16_rhs(self, other: int) -> PySeries: ...
def mul_u32_rhs(self, other: int) -> PySeries: ...
def mul_u64_rhs(self, other: int) -> PySeries: ...
def mul_i8_rhs(self, other: int) -> PySeries: ...
def mul_i16_rhs(self, other: int) -> PySeries: ...
def mul_i32_rhs(self, other: int) -> PySeries: ...
def mul_i64_rhs(self, other: int) -> PySeries: ...
def mul_f32_rhs(self, other: float) -> PySeries: ...
def mul_f64_rhs(self, other: float) -> PySeries: ...
def rem_u8_rhs(self, other: int) -> PySeries: ...
def rem_u16_rhs(self, other: int) -> PySeries: ...
def rem_u32_rhs(self, other: int) -> PySeries: ...
def rem_u64_rhs(self, other: int) -> PySeries: ...
def rem_i8_rhs(self, other: int) -> PySeries: ...
def rem_i16_rhs(self, other: int) -> PySeries: ...
def rem_i32_rhs(self, other: int) -> PySeries: ...
def rem_i64_rhs(self, other: int) -> PySeries: ...
def rem_f32_rhs(self, other: float) -> PySeries: ...
def rem_f64_rhs(self, other: float) -> PySeries: ...
# buffers
@staticmethod
def _from_buffers(
dtype: Any,
data: Sequence[PySeries],
validity: PySeries | None,
) -> PySeries: ...
@staticmethod
def _from_buffer(
dtype: DataType,
buffer_info: BufferInfo,
owner: Any,
) -> PySeries: ...
def _get_buffer_info(self) -> BufferInfo: ...
def _get_buffers(self) -> tuple[PySeries, PySeries | None, PySeries | None]: ...
# c_interface
@staticmethod
def _import_arrow_from_c(
name: str, chunks: Sequence[tuple[int, int]]
) -> PySeries: ...
def _export_arrow_to_c(self, out_ptr: int, out_schema_ptr: int) -> None: ...
# comparison
# Comparison with another PySeries
def eq(self, rhs: PySeries) -> PySeries: ...
def neq(self, rhs: PySeries) -> PySeries: ...
def gt(self, rhs: PySeries) -> PySeries: ...
def gt_eq(self, rhs: PySeries) -> PySeries: ...
def lt(self, rhs: PySeries) -> PySeries: ...
def lt_eq(self, rhs: PySeries) -> PySeries: ...
# Comparison with scalar values
def eq_u8(self, rhs: int) -> PySeries: ...
def eq_u16(self, rhs: int) -> PySeries: ...
def eq_u32(self, rhs: int) -> PySeries: ...
def eq_u64(self, rhs: int) -> PySeries: ...
def eq_i8(self, rhs: int) -> PySeries: ...
def eq_i16(self, rhs: int) -> PySeries: ...
def eq_i32(self, rhs: int) -> PySeries: ...
def eq_i64(self, rhs: int) -> PySeries: ...
def eq_i128(self, rhs: int) -> PySeries: ...
def eq_f32(self, rhs: float) -> PySeries: ...
def eq_f64(self, rhs: float) -> PySeries: ...
def eq_str(self, rhs: str) -> PySeries: ...
def eq_decimal(self, rhs: Any) -> PySeries: ...
def neq_u8(self, rhs: int) -> PySeries: ...
def neq_u16(self, rhs: int) -> PySeries: ...
def neq_u32(self, rhs: int) -> PySeries: ...
def neq_u64(self, rhs: int) -> PySeries: ...
def neq_i8(self, rhs: int) -> PySeries: ...
def neq_i16(self, rhs: int) -> PySeries: ...
def neq_i32(self, rhs: int) -> PySeries: ...
def neq_i64(self, rhs: int) -> PySeries: ...
def neq_i128(self, rhs: int) -> PySeries: ...
def neq_f32(self, rhs: float) -> PySeries: ...
def neq_f64(self, rhs: float) -> PySeries: ...
def neq_str(self, rhs: str) -> PySeries: ...
def neq_decimal(self, rhs: Any) -> PySeries: ...
def gt_u8(self, rhs: int) -> PySeries: ...
def gt_u16(self, rhs: int) -> PySeries: ...
def gt_u32(self, rhs: int) -> PySeries: ...
def gt_u64(self, rhs: int) -> PySeries: ...
def gt_i8(self, rhs: int) -> PySeries: ...
def gt_i16(self, rhs: int) -> PySeries: ...
def gt_i32(self, rhs: int) -> PySeries: ...
def gt_i64(self, rhs: int) -> PySeries: ...
def gt_i128(self, rhs: int) -> PySeries: ...
def gt_f32(self, rhs: float) -> PySeries: ...
def gt_f64(self, rhs: float) -> PySeries: ...
def gt_str(self, rhs: str) -> PySeries: ...
def gt_decimal(self, rhs: Any) -> PySeries: ...
def gt_eq_u8(self, rhs: int) -> PySeries: ...
def gt_eq_u16(self, rhs: int) -> PySeries: ...
def gt_eq_u32(self, rhs: int) -> PySeries: ...
def gt_eq_u64(self, rhs: int) -> PySeries: ...
def gt_eq_i8(self, rhs: int) -> PySeries: ...
def gt_eq_i16(self, rhs: int) -> PySeries: ...
def gt_eq_i32(self, rhs: int) -> PySeries: ...
def gt_eq_i64(self, rhs: int) -> PySeries: ...
def gt_eq_i128(self, rhs: int) -> PySeries: ...
def gt_eq_f32(self, rhs: float) -> PySeries: ...
def gt_eq_f64(self, rhs: float) -> PySeries: ...
def gt_eq_str(self, rhs: str) -> PySeries: ...
def gt_eq_decimal(self, rhs: Any) -> PySeries: ...
def lt_u8(self, rhs: int) -> PySeries: ...
def lt_u16(self, rhs: int) -> PySeries: ...
def lt_u32(self, rhs: int) -> PySeries: ...
def lt_u64(self, rhs: int) -> PySeries: ...
def lt_i8(self, rhs: int) -> PySeries: ...
def lt_i16(self, rhs: int) -> PySeries: ...
def lt_i32(self, rhs: int) -> PySeries: ...
def lt_i64(self, rhs: int) -> PySeries: ...
def lt_i128(self, rhs: int) -> PySeries: ...
def lt_f32(self, rhs: float) -> PySeries: ...
def lt_f64(self, rhs: float) -> PySeries: ...
def lt_str(self, rhs: str) -> PySeries: ...
def lt_decimal(self, rhs: Any) -> PySeries: ...
def lt_eq_u8(self, rhs: int) -> PySeries: ...
def lt_eq_u16(self, rhs: int) -> PySeries: ...
def lt_eq_u32(self, rhs: int) -> PySeries: ...
def lt_eq_u64(self, rhs: int) -> PySeries: ...
def lt_eq_i8(self, rhs: int) -> PySeries: ...
def lt_eq_i16(self, rhs: int) -> PySeries: ...
def lt_eq_i32(self, rhs: int) -> PySeries: ...
def lt_eq_i64(self, rhs: int) -> PySeries: ...
def lt_eq_i128(self, rhs: int) -> PySeries: ...
def lt_eq_f32(self, rhs: float) -> PySeries: ...
def lt_eq_f64(self, rhs: float) -> PySeries: ...
def lt_eq_str(self, rhs: str) -> PySeries: ...
def lt_eq_decimal(self, rhs: Any) -> PySeries: ...
# construction
@staticmethod
def new_i8(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_i16(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_i32(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_i64(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_u8(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_u16(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_u32(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_u64(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_bool(name: str, array: NDArray1D, _strict: bool) -> PySeries: ...
@staticmethod
def new_f32(name: str, array: NDArray1D, nan_is_null: bool) -> PySeries: ...
@staticmethod
def new_f64(name: str, array: NDArray1D, nan_is_null: bool) -> PySeries: ...
@staticmethod
def new_opt_bool(name: str, values: Any, _strict: bool) -> PySeries: ...
@staticmethod
def new_opt_u8(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_u16(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_u32(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_u64(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_u128(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_i8(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_i16(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_i32(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_i64(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_i128(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_f32(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_opt_f64(name: str, obj: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_from_any_values(name: str, values: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_from_any_values_and_dtype(
name: str, values: Any, dtype: DataType, strict: bool
) -> PySeries: ...
@staticmethod
def new_str(name: str, values: Any, _strict: bool) -> PySeries: ...
@staticmethod
def new_binary(name: str, values: Any, _strict: bool) -> PySeries: ...
@staticmethod
def new_decimal(name: str, values: Any, strict: bool) -> PySeries: ...
@staticmethod
def new_series_list(
name: str, values: Sequence[PySeries | None], _strict: bool
) -> PySeries: ...
@staticmethod
def new_array(
name: str, values: Any, strict: bool, dtype: DataType
) -> PySeries: ...
@staticmethod
def new_object(name: str, values: Sequence[Any], _strict: bool) -> PySeries: ...
@staticmethod
def new_null(name: str, values: Any, _strict: bool) -> PySeries: ...
@staticmethod
def from_arrow(name: str, array: Any) -> PySeries: ...
# export
def to_list(self) -> list[Any]: ...
def to_arrow(self, compat_level: Any) -> Any: ...
def __arrow_c_stream__(self, requested_schema: Any | None) -> Any: ...
def _export(self, location: int) -> None: ...
# import
@classmethod
def from_arrow_c_array(cls, ob: Any) -> PySeries: ...
@classmethod
def from_arrow_c_stream(cls, ob: Any) -> PySeries: ...
@classmethod
def _import(cls, location: int) -> PySeries: ...
# numpy ufunc
def apply_ufunc_f32(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_f64(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_u8(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_u16(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_u32(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_u64(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_i8(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_i16(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_i32(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
def apply_ufunc_i64(self, lambda_func: Any, allocate_out: bool) -> PySeries: ...
# scatter
def scatter(self, idx: PySeries, values: PySeries) -> None: ...
# interop
def to_numpy(self, writable: bool, allow_copy: bool) -> Any: ...
def to_numpy_view(self) -> Any | None: ...
@staticmethod
def _import_decimal_from_iceberg_binary_repr(
*, bytes_list: Sequence[bytes | None], precision: int, scale: int
) -> PySeries: ...
class PyDataFrame:
# general
@overload
def __init__(self, columns: Sequence[PySeries]) -> None: ...
@overload
def __init__(self, data: Any, columns: Any, orient: Any) -> None: ...
@overload
def __init__(self, schema: dict[str, Any]) -> None: ...
def estimated_size(self) -> int: ...
def dtype_strings(self) -> list[str]: ...
def add(self, s: PySeries) -> PyDataFrame: ...
def sub(self, s: PySeries) -> PyDataFrame: ...
def mul(self, s: PySeries) -> PyDataFrame: ...
def div(self, s: PySeries) -> PyDataFrame: ...
def rem(self, s: PySeries) -> PyDataFrame: ...
def add_df(self, s: PyDataFrame) -> PyDataFrame: ...
def sub_df(self, s: PyDataFrame) -> PyDataFrame: ...
def mul_df(self, s: PyDataFrame) -> PyDataFrame: ...
def div_df(self, s: PyDataFrame) -> PyDataFrame: ...
def rem_df(self, s: PyDataFrame) -> PyDataFrame: ...
def sample_n(
self, n: PySeries, with_replacement: bool, shuffle: bool, seed: int | None
) -> PyDataFrame: ...
def sample_frac(
self,
frac: PySeries,
with_replacement: bool,
shuffle: bool,
seed: int | None,
) -> PyDataFrame: ...
def rechunk(self) -> PyDataFrame: ...
def as_str(self) -> str: ...
def get_columns(self) -> list[PySeries]: ...
def columns(self) -> list[str]: ...
def set_column_names(self, names: Sequence[str]) -> None: ...
def dtypes(self) -> list[Any]: ...
def n_chunks(self) -> int: ...
def shape(self) -> tuple[int, int]: ...
def height(self) -> int: ...
def width(self) -> int: ...
def is_empty(self) -> bool: ...
def hstack(self, columns: Sequence[PySeries]) -> PyDataFrame: ...
def hstack_mut(self, columns: Sequence[PySeries]) -> None: ...
def vstack(self, other: PyDataFrame) -> PyDataFrame: ...
def vstack_mut(self, other: PyDataFrame) -> None: ...
def extend(self, other: PyDataFrame) -> None: ...
def drop_in_place(self, name: str) -> PySeries: ...
def to_series(self, index: int) -> PySeries: ...
def get_column_index(self, name: str) -> int: ...
def get_column(self, name: str) -> PySeries: ...
def select(self, columns: Sequence[str]) -> PyDataFrame: ...
def gather(self, indices: Sequence[int]) -> PyDataFrame: ...
def gather_with_series(self, indices: PySeries) -> PyDataFrame: ...
def replace(self, column: str, new_col: PySeries) -> None: ...
def replace_column(self, index: int, new_column: PySeries) -> None: ...
def insert_column(self, index: int, column: PySeries) -> None: ...
def slice(self, offset: int, length: int | None) -> PyDataFrame: ...
def head(self, n: int) -> PyDataFrame: ...
def tail(self, n: int) -> PyDataFrame: ...
def is_unique(self) -> PySeries: ...
def is_duplicated(self) -> PySeries: ...
def equals(self, other: PyDataFrame, null_equal: bool) -> bool: ...
def with_row_index(self, name: str, offset: int | None) -> PyDataFrame: ...
def _to_metadata(self) -> PyDataFrame: ...
def group_by_map_groups(
self, by: Sequence[str], lambda_func: Any, maintain_order: bool
) -> PyDataFrame: ...
def clone(self) -> PyDataFrame: ...
def unpivot(
self,
on: Sequence[str],
index: Sequence[str],
value_name: str | None,
variable_name: str | None,
) -> PyDataFrame: ...
def pivot_expr(
self,
on: Sequence[str],
index: Sequence[str] | None,
values: Sequence[str] | None,
maintain_order: bool,
sort_columns: bool,
aggregate_expr: Any | None,
separator: str | None,
) -> PyDataFrame: ...
def partition_by(
self, by: Sequence[str], maintain_order: bool, include_key: bool
) -> list[PyDataFrame]: ...
def lazy(self) -> PyLazyFrame: ...
def to_dummies(
self,
columns: Sequence[str] | None,
separator: str | None,
drop_first: bool,
drop_nulls: bool,
) -> PyDataFrame: ...
def null_count(self) -> PyDataFrame: ...
def map_rows(
self,
lambda_func: Any,
output_type: Any | None,
inference_size: int,
) -> tuple[Any, bool]: ...
def shrink_to_fit(self) -> None: ...
def hash_rows(self, k0: int, k1: int, k2: int, k3: int) -> PySeries: ...
def transpose(
self, keep_names_as: str | None, column_names: None | str | Sequence[str]
) -> PyDataFrame: ...
def upsample(
self,
by: Sequence[str],
index_column: str,
every: str,
stable: bool,
) -> PyDataFrame: ...
def to_struct(self, name: str, invalid_indices: Sequence[int]) -> PySeries: ...
def clear(self) -> PyDataFrame: ...
def _export_columns(self, location: int) -> None: ...
@classmethod
def _import_columns(cls, location: int, width: int) -> PyDataFrame: ...
def _row_encode(self, opts: Sequence[tuple[bool, bool, bool]]) -> PySeries: ...
# construction
@staticmethod
def from_rows(
data: Sequence[PySeries],
schema: Any | None,
infer_schema_length: int | None,
) -> PyDataFrame: ...
@staticmethod
def from_dicts(
data: Any,
schema: Any | None,
schema_overrides: Any | None,
strict: bool,
infer_schema_length: int | None,
) -> PyDataFrame: ...
@staticmethod
def from_arrow_record_batches(
rb: Sequence[Any],
schema: Any,
) -> PyDataFrame: ...
# export
def row_tuple(self, idx: int) -> tuple[Any, ...]: ...
def row_tuples(self) -> list[tuple[Any, ...]]: ...
def to_arrow(self, compat_level: Any) -> list[Any]: ...
def to_pandas(self) -> list[Any]: ...
def __arrow_c_stream__(self, requested_schema: Any | None) -> Any: ...
# io
@staticmethod
def read_csv(
py_f: Any,
infer_schema_length: int | None,
chunk_size: int,
has_header: bool,
ignore_errors: bool,
n_rows: int | None,
skip_rows: int,
skip_lines: int,
projection: Sequence[int] | None,
separator: str,
rechunk: bool,
columns: Sequence[str] | None,
encoding: Any,
n_threads: int | None,
path: str | None,
overwrite_dtype: Sequence[tuple[str, DataType]] | None,
overwrite_dtype_slice: Sequence[DataType] | None,
low_memory: bool,
comment_prefix: str | None,
quote_char: str | None,
null_values: Any | None,
missing_utf8_is_empty_string: bool,
try_parse_dates: bool,
skip_rows_after_header: int,
row_index: tuple[str, int] | None,
eol_char: str,
raise_if_empty: bool,
truncate_ragged_lines: bool,
decimal_comma: bool,
schema: Any | None,
) -> PyDataFrame: ...
@staticmethod
def read_json(
py_f: Any,
infer_schema_length: int | None,
schema: Any | None,
schema_overrides: Any | None,
) -> PyDataFrame: ...
@staticmethod
def read_ipc(
py_f: Any,
columns: Sequence[str] | None,
projection: Sequence[int] | None,
n_rows: int | None,
row_index: tuple[str, int] | None,
memory_map: bool,
) -> PyDataFrame: ...
@staticmethod
def read_ipc_stream(
py_f: Any,
columns: Sequence[str] | None,
projection: Sequence[int] | None,
n_rows: int | None,
row_index: tuple[str, int] | None,
rechunk: bool,
) -> PyDataFrame: ...
@staticmethod
def read_avro(
py_f: Any,
columns: Sequence[str] | None,
projection: Sequence[int] | None,
n_rows: int | None,
) -> PyDataFrame: ...
def write_json(self, py_f: Any) -> None: ...
def write_ipc_stream(
self, py_f: Any, compression: Any, compat_level: Any
) -> None: ...
def write_avro(self, py_f: Any, compression: Any, name: str) -> None: ...
# serde
def serialize_binary(self, py_f: Any) -> None: ...
@staticmethod
def deserialize_binary(py_f: Any) -> PyDataFrame: ...
def serialize_json(self, py_f: Any) -> None: ...
@staticmethod
def deserialize_json(py_f: Any) -> PyDataFrame: ...
# interop
def to_numpy(
self,
order: IndexOrder,
writable: bool,
allow_copy: bool,
) -> Any: ...
class PyLazyFrame:
@staticmethod
def new_from_ndjson(
source: Any | None,
sources: Any,
infer_schema_length: int | None,
schema: Any | None,
schema_overrides: Any | None,
batch_size: int | None,
n_rows: int | None,
low_memory: bool,
rechunk: bool,
row_index: tuple[str, int] | None,
ignore_errors: bool,
include_file_paths: str | None,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
file_cache_ttl: int | None,
) -> PyLazyFrame: ...
@staticmethod
def new_from_csv(
source: Any | None,
sources: Any,
separator: str,
has_header: bool,
ignore_errors: bool,
skip_rows: int,
skip_lines: int,
n_rows: int | None,
cache: bool,
overwrite_dtype: Sequence[tuple[str, Any]] | None,
low_memory: bool,
comment_prefix: str | None,
quote_char: str | None,
null_values: Any | None,
missing_utf8_is_empty_string: bool,
infer_schema_length: int | None,
with_schema_modify: Any | None,
rechunk: bool,
skip_rows_after_header: int,
encoding: Any,
row_index: tuple[str, int] | None,
try_parse_dates: bool,
eol_char: str,
raise_if_empty: bool,
truncate_ragged_lines: bool,
decimal_comma: bool,
glob: bool,
schema: Any | None,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
file_cache_ttl: int | None,
include_file_paths: str | None,
) -> PyLazyFrame: ...
@staticmethod
def new_from_parquet(
sources: Any,
schema: Any | None,
scan_options: ScanOptions,
parallel: Any,
low_memory: bool,
use_statistics: bool,
) -> PyLazyFrame: ...
@staticmethod
def new_from_ipc(
sources: Any,
scan_options: ScanOptions,
file_cache_ttl: int | None,
) -> PyLazyFrame: ...
@staticmethod
def new_from_dataset_object(dataset_object: Any) -> PyLazyFrame: ...
@staticmethod
def scan_from_python_function_arrow_schema(
schema: Any, scan_fn: Any, pyarrow: bool, validate_schema: bool, is_pure: bool
) -> PyLazyFrame: ...
@staticmethod
def scan_from_python_function_pl_schema(
schema: Sequence[tuple[str, Any]],
scan_fn: Any,
pyarrow: bool,
validate_schema: bool,
is_pure: bool,
) -> PyLazyFrame: ...
@staticmethod
def scan_from_python_function_schema_function(
schema_fn: Any, scan_fn: Any, validate_schema: bool, is_pure: bool
) -> PyLazyFrame: ...
def pipe_with_schema(
self, callback: Callable[[tuple[PyLazyFrame, Schema]], PyLazyFrame]
) -> PyLazyFrame: ...
def describe_plan(self) -> str: ...
def describe_optimized_plan(self) -> str: ...
def describe_plan_tree(self) -> str: ...
def describe_optimized_plan_tree(self) -> str: ...
def to_dot(self, optimized: bool) -> str: ...
def to_dot_streaming_phys(self, optimized: bool) -> str: ...
def optimization_toggle(
self,
type_coercion: bool,
type_check: bool,
predicate_pushdown: bool,
projection_pushdown: bool,
simplify_expression: bool,
slice_pushdown: bool,
comm_subplan_elim: bool,
comm_subexpr_elim: bool,
cluster_with_columns: bool,
_eager: bool,
_check_order: bool,
new_streaming: bool,
) -> PyLazyFrame: ...
def sort(
self,
by_column: str,
descending: bool,
nulls_last: bool,
maintain_order: bool,
multithreaded: bool,
) -> PyLazyFrame: ...
def sort_by_exprs(
self,
by: Sequence[PyExpr],
descending: Sequence[bool],
nulls_last: Sequence[bool],
maintain_order: bool,
multithreaded: bool,
) -> PyLazyFrame: ...
def top_k(
self, k: int, by: Sequence[PyExpr], reverse: Sequence[bool]
) -> PyLazyFrame: ...
def bottom_k(
self, k: int, by: Sequence[PyExpr], reverse: Sequence[bool]
) -> PyLazyFrame: ...
def cache(self) -> PyLazyFrame: ...
def with_optimizations(self, optflags: PyOptFlags) -> PyLazyFrame: ...
def profile(
self, lambda_post_opt: Any | None
) -> tuple[PyDataFrame, PyDataFrame]: ...
def collect(self, engine: Any, lambda_post_opt: Any | None) -> PyDataFrame: ...
def collect_with_callback(self, engine: Any, lambda_func: Any) -> None: ...
def sink_parquet(
self,
target: SinkTarget,
compression: str,
compression_level: int | None,
statistics: StatisticsOptions,
row_group_size: int | None,
data_page_size: int | None,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
sink_options: Any,
metadata: KeyValueMetadata | None,
field_overwrites: Sequence[ParquetFieldOverwrites],
) -> PyLazyFrame: ...
def sink_ipc(
self,
target: SinkTarget,
compression: IpcCompression | None,
compat_level: CompatLevel,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
sink_options: Any,
) -> PyLazyFrame: ...
def sink_csv(
self,
target: SinkTarget,
include_bom: bool,
include_header: bool,
separator: int,
line_terminator: str,
quote_char: int,
batch_size: int,
datetime_format: str | None,
date_format: str | None,
time_format: str | None,
float_scientific: bool | None,
float_precision: int | None,
decimal_comma: bool,
null_value: str | None,
quote_style: QuoteStyle | None,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
sink_options: Any,
) -> PyLazyFrame: ...
def sink_json(
self,
target: SinkTarget,
cloud_options: dict[str, Any] | None,
credential_provider: Any | None,
retries: int,
sink_options: Any,
) -> PyLazyFrame: ...
def sink_batches(
self,
function: Callable[[PyDataFrame], bool],
maintain_order: bool,
chunk_size: int | None,
) -> PyLazyFrame: ...
def filter(self, predicate: PyExpr) -> PyLazyFrame: ...
def remove(self, predicate: PyExpr) -> PyLazyFrame: ...
def select(self, exprs: Sequence[PyExpr]) -> PyLazyFrame: ...
def select_seq(self, exprs: Sequence[PyExpr]) -> PyLazyFrame: ...
def group_by(self, by: Sequence[PyExpr], maintain_order: bool) -> PyLazyGroupBy: ...
def rolling(
self,
index_column: PyExpr,
period: str,
offset: str,
closed: ClosedWindow,
by: Sequence[PyExpr],
) -> PyLazyGroupBy: ...
def group_by_dynamic(
self,
index_column: PyExpr,
every: str,
period: str,
offset: str,
label: Label,
include_boundaries: bool,
closed: ClosedWindow,
group_by: Sequence[PyExpr],
start_by: StartBy,
) -> PyLazyGroupBy: ...
def with_context(self, contexts: Sequence[PyLazyFrame]) -> PyLazyFrame: ...
def join_asof(
self,
other: PyLazyFrame,
left_on: PyExpr,
right_on: PyExpr,
left_by: Sequence[str] | None,
right_by: Sequence[str] | None,
allow_parallel: bool,
force_parallel: bool,
suffix: str,
strategy: AsofStrategy,
tolerance: Any | None,
tolerance_str: str | None,
coalesce: bool,
allow_eq: bool,
check_sortedness: bool,
) -> PyLazyFrame: ...
def join(
self,
other: PyLazyFrame,
left_on: Sequence[PyExpr],
right_on: Sequence[PyExpr],
allow_parallel: bool,
force_parallel: bool,
nulls_equal: bool,
how: JoinType,
suffix: str,
validate: JoinValidation,
maintain_order: MaintainOrderJoin,
coalesce: bool | None,
) -> PyLazyFrame: ...
def join_where(
self, other: PyLazyFrame, predicates: Sequence[PyExpr], suffix: str
) -> PyLazyFrame: ...
def with_columns(self, exprs: Sequence[PyExpr]) -> PyLazyFrame: ...
def with_columns_seq(self, exprs: Sequence[PyExpr]) -> PyLazyFrame: ...
def match_to_schema(
self,
schema: Schema,
missing_columns: Any,
missing_struct_fields: Any,
extra_columns: ExtraColumnsPolicy,
extra_struct_fields: Any,
integer_cast: Any,
float_cast: Any,
) -> PyLazyFrame: ...
def rename(
self, existing: Sequence[str], new: Sequence[str], strict: bool
) -> PyLazyFrame: ...
def reverse(self) -> PyLazyFrame: ...
def shift(self, n: PyExpr, fill_value: PyExpr | None) -> PyLazyFrame: ...
def fill_nan(self, fill_value: PyExpr) -> PyLazyFrame: ...
def min(self) -> PyLazyFrame: ...
def max(self) -> PyLazyFrame: ...
def sum(self) -> PyLazyFrame: ...
def mean(self) -> PyLazyFrame: ...
def std(self, ddof: int) -> PyLazyFrame: ...
def var(self, ddof: int) -> PyLazyFrame: ...
def median(self) -> PyLazyFrame: ...
def quantile(
self, quantile: PyExpr, interpolation: QuantileMethod
) -> PyLazyFrame: ...
def explode(self, subset: PySelector) -> PyLazyFrame: ...
def null_count(self) -> PyLazyFrame: ...
def unique(
self,
maintain_order: bool,
subset: PySelector | None,
keep: UniqueKeepStrategy,
) -> PyLazyFrame: ...
def drop_nans(self, subset: PySelector | None) -> PyLazyFrame: ...
def drop_nulls(self, subset: PySelector | None) -> PyLazyFrame: ...
def slice(self, offset: int, len: int | None) -> PyLazyFrame: ...
def tail(self, n: int) -> PyLazyFrame: ...
def unpivot(
self,
on: PySelector,
index: PySelector,
value_name: str | None,
variable_name: str | None,
) -> PyLazyFrame: ...
def with_row_index(self, name: str, offset: int | None = None) -> PyLazyFrame: ...
def map_batches(
self,
function: Any,
predicate_pushdown: bool,
projection_pushdown: bool,
slice_pushdown: bool,
streamable: bool,
schema: Schema | None,
validate_output: bool,
) -> PyLazyFrame: ...
def drop(self, columns: PySelector) -> PyLazyFrame: ...
def cast(self, dtypes: dict[str, DataType], strict: bool) -> PyLazyFrame: ...
def cast_all(self, dtype: PyDataTypeExpr, strict: bool) -> PyLazyFrame: ...
def clone(self) -> PyLazyFrame: ...
def collect_schema(self) -> dict[str, Any]: ...
def unnest(self, columns: PySelector, separator: str | None) -> PyLazyFrame: ...
def count(self) -> PyLazyFrame: ...
def merge_sorted(self, other: PyLazyFrame, key: str) -> PyLazyFrame: ...
def hint_sorted(
self, columns: list[str], descending: list[bool], nulls_last: list[bool]
) -> PyLazyFrame: ...
# exitable
def collect_concurrently(self) -> PyInProcessQuery: ...
# serde
def serialize_binary(self, py_f: Any) -> None: ...
def serialize_json(self, py_f: Any) -> None: ...
@staticmethod
def deserialize_binary(py_f: Any) -> PyLazyFrame: ...
@staticmethod
def deserialize_json(py_f: Any) -> PyLazyFrame: ...
# visit
def visit(self) -> NodeTraverser: ...
class PyInProcessQuery:
def cancel(self) -> None: ...
def fetch(self) -> PyDataFrame | None: ...
def fetch_blocking(self) -> PyDataFrame: ...
class PyExpr:
def __init__(self, inner: Any) -> None: ...
def __richcmp__(self, other: PyExpr, op: Any) -> PyExpr: ...
def __add__(self, rhs: PyExpr) -> PyExpr: ...
def __sub__(self, rhs: PyExpr) -> PyExpr: ...
def __mul__(self, rhs: PyExpr) -> PyExpr: ...
def __truediv__(self, rhs: PyExpr) -> PyExpr: ...
def __mod__(self, rhs: PyExpr) -> PyExpr: ...
def __floordiv__(self, rhs: PyExpr) -> PyExpr: ...
def __neg__(self) -> PyExpr: ...
def to_str(self) -> str: ...
def eq(self, other: PyExpr) -> PyExpr: ...
def eq_missing(self, other: PyExpr) -> PyExpr: ...
def neq(self, other: PyExpr) -> PyExpr: ...
def neq_missing(self, other: PyExpr) -> PyExpr: ...
def gt(self, other: PyExpr) -> PyExpr: ...
def gt_eq(self, other: PyExpr) -> PyExpr: ...
def lt_eq(self, other: PyExpr) -> PyExpr: ...
def lt(self, other: PyExpr) -> PyExpr: ...
def alias(self, name: str) -> PyExpr: ...
def not_(self) -> PyExpr: ...
def is_null(self) -> PyExpr: ...
def is_not_null(self) -> PyExpr: ...
def is_infinite(self) -> PyExpr: ...
def is_finite(self) -> PyExpr: ...
def is_nan(self) -> PyExpr: ...
def is_not_nan(self) -> PyExpr: ...
def min(self) -> PyExpr: ...
def max(self) -> PyExpr: ...
def nan_max(self) -> PyExpr: ...
def nan_min(self) -> PyExpr: ...
def mean(self) -> PyExpr: ...
def median(self) -> PyExpr: ...
def sum(self) -> PyExpr: ...
def n_unique(self) -> PyExpr: ...
def arg_unique(self) -> PyExpr: ...
def unique(self) -> PyExpr: ...
def unique_stable(self) -> PyExpr: ...
def first(self) -> PyExpr: ...
def last(self) -> PyExpr: ...
def item(self, *, allow_empty: bool) -> PyExpr: ...
def implode(self) -> PyExpr: ...
def quantile(self, quantile: PyExpr, interpolation: Any) -> PyExpr: ...
def cut(
self,
breaks: Sequence[float],
labels: Sequence[str] | None,
left_closed: bool,
include_breaks: bool,
) -> PyExpr: ...
def qcut(
self,
probs: Sequence[float],
labels: Sequence[str] | None,
left_closed: bool,
allow_duplicates: bool,
include_breaks: bool,
) -> PyExpr: ...
def qcut_uniform(
self,
n_bins: int,
labels: Sequence[str] | None,
left_closed: bool,
allow_duplicates: bool,
include_breaks: bool,
) -> PyExpr: ...
def rle(self) -> PyExpr: ...
def rle_id(self) -> PyExpr: ...
def agg_groups(self) -> PyExpr: ...
def count(self) -> PyExpr: ...
def len(self) -> PyExpr: ...
def value_counts(
self, sort: bool, parallel: bool, name: str, normalize: bool
) -> PyExpr: ...
def unique_counts(self) -> PyExpr: ...
def null_count(self) -> PyExpr: ...
def cast(
self, dtype: PyDataTypeExpr, strict: bool, wrap_numerical: bool
) -> PyExpr: ...
def sort_with(self, descending: bool, nulls_last: bool) -> PyExpr: ...
def arg_sort(self, descending: bool, nulls_last: bool) -> PyExpr: ...
def top_k(self, k: PyExpr) -> PyExpr: ...
def top_k_by(
self, by: Sequence[PyExpr], k: PyExpr, reverse: Sequence[bool]
) -> PyExpr: ...
def bottom_k(self, k: PyExpr) -> PyExpr: ...
def bottom_k_by(
self, by: Sequence[PyExpr], k: PyExpr, reverse: Sequence[bool]
) -> PyExpr: ...
def peak_min(self) -> PyExpr: ...
def peak_max(self) -> PyExpr: ...
def arg_max(self) -> PyExpr: ...
def arg_min(self) -> PyExpr: ...
def index_of(self, element: PyExpr) -> PyExpr: ...
def search_sorted(self, element: PyExpr, side: Any, descending: bool) -> PyExpr: ...
def gather(self, idx: PyExpr) -> PyExpr: ...
def get(self, idx: PyExpr) -> PyExpr: ...
def sort_by(
self,
by: Sequence[PyExpr],
descending: Sequence[bool],
nulls_last: Sequence[bool],
multithreaded: bool,
maintain_order: bool,
) -> PyExpr: ...
def shift(self, n: PyExpr, fill_value: PyExpr | None) -> PyExpr: ...
def fill_null(self, expr: PyExpr) -> PyExpr: ...
def fill_null_with_strategy(self, strategy: str, limit: Any) -> PyExpr: ...
def fill_nan(self, expr: PyExpr) -> PyExpr: ...
def drop_nulls(self) -> PyExpr: ...
def drop_nans(self) -> PyExpr: ...
def filter(self, predicate: PyExpr) -> PyExpr: ...
def reverse(self) -> PyExpr: ...
def std(self, ddof: int) -> PyExpr: ...
def var(self, ddof: int) -> PyExpr: ...
def is_unique(self) -> PyExpr: ...
def is_between(self, lower: PyExpr, upper: PyExpr, closed: Any) -> PyExpr: ...
def is_close(
self, other: PyExpr, abs_tol: float, rel_tol: float, nans_equal: bool
) -> PyExpr: ...
def approx_n_unique(self) -> PyExpr: ...
def is_first_distinct(self) -> PyExpr: ...
def is_last_distinct(self) -> PyExpr: ...
def explode(self) -> PyExpr: ...
def gather_every(self, n: int, offset: int) -> PyExpr: ...
def slice(self, offset: PyExpr, length: PyExpr) -> PyExpr: ...
def append(self, other: PyExpr, upcast: bool) -> PyExpr: ...
def rechunk(self) -> PyExpr: ...
def round(self, decimals: int, mode: Any) -> PyExpr: ...
def round_sig_figs(self, digits: int) -> PyExpr: ...
def floor(self) -> PyExpr: ...
def ceil(self) -> PyExpr: ...
def clip(self, min: PyExpr | None, max: PyExpr | None) -> PyExpr: ...
def abs(self) -> PyExpr: ...
def sin(self) -> PyExpr: ...
def cos(self) -> PyExpr: ...
def tan(self) -> PyExpr: ...
def cot(self) -> PyExpr: ...
def arcsin(self) -> PyExpr: ...
def arccos(self) -> PyExpr: ...
def arctan(self) -> PyExpr: ...
def arctan2(self, y: PyExpr) -> PyExpr: ...
def sinh(self) -> PyExpr: ...
def cosh(self) -> PyExpr: ...
def tanh(self) -> PyExpr: ...
def arcsinh(self) -> PyExpr: ...
def arccosh(self) -> PyExpr: ...
def arctanh(self) -> PyExpr: ...
def degrees(self) -> PyExpr: ...
def radians(self) -> PyExpr: ...
def sign(self) -> PyExpr: ...
def is_duplicated(self) -> PyExpr: ...
def over(
self,
partition_by: Sequence[PyExpr] | None,
order_by: Sequence[PyExpr] | None,
order_by_descending: bool,
order_by_nulls_last: bool,
mapping_strategy: Any,
) -> PyExpr: ...
def rolling(
self, index_column: str, period: str, offset: str, closed: Any
) -> PyExpr: ...
def and_(self, expr: PyExpr) -> PyExpr: ...
def or_(self, expr: PyExpr) -> PyExpr: ...
def xor_(self, expr: PyExpr) -> PyExpr: ...
def is_in(self, expr: PyExpr, nulls_equal: bool) -> PyExpr: ...
def repeat_by(self, by: PyExpr) -> PyExpr: ...
def pow(self, exponent: PyExpr) -> PyExpr: ...
def sqrt(self) -> PyExpr: ...
def cbrt(self) -> PyExpr: ...
def cum_sum(self, reverse: bool) -> PyExpr: ...
def cum_max(self, reverse: bool) -> PyExpr: ...
def cum_min(self, reverse: bool) -> PyExpr: ...
def cum_prod(self, reverse: bool) -> PyExpr: ...
def cum_count(self, reverse: bool) -> PyExpr: ...
def cumulative_eval(self, expr: PyExpr, min_samples: int) -> PyExpr: ...
def product(self) -> PyExpr: ...
def shrink_dtype(self) -> PyExpr: ...
def dot(self, other: PyExpr) -> PyExpr: ...
def reinterpret(self, signed: bool) -> PyExpr: ...
def mode(self) -> PyExpr: ...
def interpolate(self, method: Any) -> PyExpr: ...
def interpolate_by(self, by: PyExpr) -> PyExpr: ...
def lower_bound(self) -> PyExpr: ...
def upper_bound(self) -> PyExpr: ...
def rank(self, method: Any, descending: bool, seed: int | None) -> PyExpr: ...
def diff(self, n: PyExpr, null_behavior: Any) -> PyExpr: ...
def pct_change(self, n: PyExpr) -> PyExpr: ...
def skew(self, bias: bool) -> PyExpr: ...
def kurtosis(self, fisher: bool, bias: bool) -> PyExpr: ...
def reshape(self, dims: Sequence[int]) -> PyExpr: ...
def to_physical(self) -> PyExpr: ...
def shuffle(self, seed: int | None) -> PyExpr: ...
def sample_n(
self, n: PyExpr, with_replacement: bool, shuffle: bool, seed: int | None
) -> PyExpr: ...
def sample_frac(
self, frac: PyExpr, with_replacement: bool, shuffle: bool, seed: int | None
) -> PyExpr: ...
def ewm_mean(
self, alpha: float, adjust: bool, min_periods: int, ignore_nulls: bool
) -> PyExpr: ...
def ewm_mean_by(self, times: PyExpr, half_life: str) -> PyExpr: ...
def ewm_std(
self,
alpha: float,
adjust: bool,
bias: bool,
min_periods: int,
ignore_nulls: bool,
) -> PyExpr: ...
def ewm_var(
self,
alpha: float,
adjust: bool,
bias: bool,
min_periods: int,
ignore_nulls: bool,
) -> PyExpr: ...
def extend_constant(self, value: PyExpr, n: PyExpr) -> PyExpr: ...
def any(self, ignore_nulls: bool) -> PyExpr: ...
def all(self, ignore_nulls: bool) -> PyExpr: ...
def log(self, base: PyExpr) -> PyExpr: ...
def log1p(self) -> PyExpr: ...
def exp(self) -> PyExpr: ...
def entropy(self, base: float, normalize: bool) -> PyExpr: ...
def hash(self, seed: int, seed_1: int, seed_2: int, seed_3: int) -> PyExpr: ...
def set_sorted_flag(self, descending: bool) -> PyExpr: ...
def replace(self, old: PyExpr, new: PyExpr) -> PyExpr: ...
def replace_strict(
self,
old: PyExpr,
new: PyExpr,
default: PyExpr | None,
return_dtype: PyDataTypeExpr | None,
) -> PyExpr: ...
def hist(
self,
bins: PyExpr | None,
bin_count: int | None,
include_category: bool,
include_breakpoint: bool,
) -> PyExpr: ...
def skip_batch_predicate(self, schema: Any) -> PyExpr | None: ...
@staticmethod
def row_encode_unordered(exprs: Sequence[PyExpr]) -> PyExpr: ...
@staticmethod
def row_encode_ordered(
exprs: Sequence[PyExpr],
descending: Sequence[bool] | None,
nulls_last: Sequence[bool] | None,
) -> PyExpr: ...
def row_decode_unordered(
self, names: Sequence[str], datatypes: Sequence[PyDataTypeExpr]
) -> PyExpr: ...
def row_decode_ordered(
self,
names: Sequence[str],
datatypes: Sequence[PyDataTypeExpr],
descending: Sequence[bool] | None,
nulls_last: Sequence[bool] | None,
) -> PyExpr: ...
def into_selector(self) -> Any: ...
@staticmethod
def new_selector(selector: Any) -> PyExpr: ...
# array
def arr_len(self) -> PyExpr: ...
def arr_max(self) -> PyExpr: ...
def arr_min(self) -> PyExpr: ...
def arr_sum(self) -> PyExpr: ...
def arr_std(self, ddof: int) -> PyExpr: ...
def arr_var(self, ddof: int) -> PyExpr: ...
def arr_mean(self) -> PyExpr: ...
def arr_median(self) -> PyExpr: ...
def arr_unique(self, maintain_order: bool) -> PyExpr: ...
def arr_n_unique(self) -> PyExpr: ...
def arr_to_list(self) -> PyExpr: ...
def arr_all(self) -> PyExpr: ...
def arr_any(self) -> PyExpr: ...
def arr_sort(self, descending: bool, nulls_last: bool) -> PyExpr: ...
def arr_reverse(self) -> PyExpr: ...
def arr_arg_min(self) -> PyExpr: ...
def arr_arg_max(self) -> PyExpr: ...
def arr_get(self, index: PyExpr, null_on_oob: bool) -> PyExpr: ...
def arr_join(self, separator: PyExpr, ignore_nulls: bool) -> PyExpr: ...
def arr_contains(self, other: PyExpr, nulls_equal: bool) -> PyExpr: ...
def arr_count_matches(self, expr: PyExpr) -> PyExpr: ...
def arr_to_struct(self, name_gen: Any | None = None) -> PyExpr: ...
def arr_slice(
self, offset: PyExpr, length: PyExpr | None = None, as_array: bool = False
) -> PyExpr: ...
def arr_tail(self, n: PyExpr, as_array: bool) -> PyExpr: ...
def arr_shift(self, n: PyExpr) -> PyExpr: ...
def arr_explode(self) -> PyExpr: ...
def arr_eval(self, expr: PyExpr, *, as_list: bool) -> PyExpr: ...
def arr_agg(self, expr: PyExpr) -> PyExpr: ...
# binary
def bin_contains(self, lit: PyExpr) -> PyExpr: ...
def bin_ends_with(self, sub: PyExpr) -> PyExpr: ...
def bin_starts_with(self, sub: PyExpr) -> PyExpr: ...
def bin_hex_decode(self, strict: bool) -> PyExpr: ...
def bin_base64_decode(self, strict: bool) -> PyExpr: ...
def bin_hex_encode(self) -> PyExpr: ...
def bin_base64_encode(self) -> PyExpr: ...
def bin_reinterpret(self, dtype: PyDataTypeExpr, kind: str) -> PyExpr: ...
def bin_size_bytes(self) -> PyExpr: ...
# bitwise
def bitwise_count_ones(self) -> PyExpr: ...
def bitwise_count_zeros(self) -> PyExpr: ...
def bitwise_leading_ones(self) -> PyExpr: ...
def bitwise_leading_zeros(self) -> PyExpr: ...
def bitwise_trailing_ones(self) -> PyExpr: ...
def bitwise_trailing_zeros(self) -> PyExpr: ...
def bitwise_and(self) -> PyExpr: ...
def bitwise_or(self) -> PyExpr: ...
def bitwise_xor(self) -> PyExpr: ...
# categorical
def cat_get_categories(self) -> PyExpr: ...
def cat_len_bytes(self) -> PyExpr: ...
def cat_len_chars(self) -> PyExpr: ...
def cat_starts_with(self, prefix: str) -> PyExpr: ...
def cat_ends_with(self, suffix: str) -> PyExpr: ...
def cat_slice(self, offset: int, length: int | None = None) -> PyExpr: ...
# datetime
def dt_add_business_days(
self, n: PyExpr, week_mask: Sequence[bool], holidays: Sequence[int], roll: Roll
) -> PyExpr: ...
def dt_to_string(self, format: str) -> PyExpr: ...
def dt_offset_by(self, by: PyExpr) -> PyExpr: ...
def dt_with_time_unit(self, time_unit: TimeUnit) -> PyExpr: ...
def dt_convert_time_zone(self, time_zone: str) -> PyExpr: ...
def dt_cast_time_unit(self, time_unit: TimeUnit) -> PyExpr: ...
def dt_replace_time_zone(
self,
time_zone: str | None,
ambiguous: PyExpr,
non_existent: NonExistent,
) -> PyExpr: ...
def dt_truncate(self, every: PyExpr) -> PyExpr: ...
def dt_month_start(self) -> PyExpr: ...
def dt_month_end(self) -> PyExpr: ...
def dt_base_utc_offset(self) -> PyExpr: ...
def dt_dst_offset(self) -> PyExpr: ...
def dt_round(self, every: PyExpr) -> PyExpr: ...
def dt_replace(
self,
year: PyExpr,
month: PyExpr,
day: PyExpr,
hour: PyExpr,
minute: PyExpr,
second: PyExpr,
microsecond: PyExpr,
ambiguous: PyExpr,
) -> PyExpr: ...
def dt_combine(self, time: PyExpr, time_unit: TimeUnit) -> PyExpr: ...
def dt_millennium(self) -> PyExpr: ...
def dt_century(self) -> PyExpr: ...
def dt_year(self) -> PyExpr: ...
def dt_is_business_day(
self, week_mask: Sequence[bool], holidays: Sequence[int]
) -> PyExpr: ...
def dt_is_leap_year(self) -> PyExpr: ...
def dt_iso_year(self) -> PyExpr: ...
def dt_quarter(self) -> PyExpr: ...
def dt_month(self) -> PyExpr: ...
def dt_days_in_month(self) -> PyExpr: ...
def dt_week(self) -> PyExpr: ...
def dt_weekday(self) -> PyExpr: ...
def dt_day(self) -> PyExpr: ...
def dt_ordinal_day(self) -> PyExpr: ...
def dt_time(self) -> PyExpr: ...
def dt_date(self) -> PyExpr: ...
def dt_datetime(self) -> PyExpr: ...
def dt_hour(self) -> PyExpr: ...
def dt_minute(self) -> PyExpr: ...
def dt_second(self) -> PyExpr: ...
def dt_millisecond(self) -> PyExpr: ...
def dt_microsecond(self) -> PyExpr: ...
def dt_nanosecond(self) -> PyExpr: ...
def dt_timestamp(self, time_unit: TimeUnit) -> PyExpr: ...
def dt_total_days(self, fractional: bool) -> PyExpr: ...
def dt_total_hours(self, fractional: bool) -> PyExpr: ...
def dt_total_minutes(self, fractional: bool) -> PyExpr: ...
def dt_total_seconds(self, fractional: bool) -> PyExpr: ...
def dt_total_milliseconds(self, fractional: bool) -> PyExpr: ...
def dt_total_microseconds(self, fractional: bool) -> PyExpr: ...
def dt_total_nanoseconds(self, fractional: bool) -> PyExpr: ...
# list
def list_all(self) -> PyExpr: ...
def list_any(self) -> PyExpr: ...
def list_arg_max(self) -> PyExpr: ...
def list_arg_min(self) -> PyExpr: ...
def list_contains(self, other: PyExpr, nulls_equal: bool) -> PyExpr: ...
def list_count_matches(self, expr: PyExpr) -> PyExpr: ...
def list_diff(self, n: int, null_behavior: NullBehavior) -> PyExpr: ...
def list_eval(self, expr: PyExpr, _parallel: bool) -> PyExpr: ...
def list_agg(self, expr: PyExpr) -> PyExpr: ...
def list_filter(self, predicate: PyExpr) -> PyExpr: ...
def list_get(self, index: PyExpr, null_on_oob: bool) -> PyExpr: ...
def list_join(self, separator: PyExpr, ignore_nulls: bool) -> PyExpr: ...
def list_len(self) -> PyExpr: ...
def list_max(self) -> PyExpr: ...
def list_mean(self) -> PyExpr: ...
def list_median(self) -> PyExpr: ...
def list_std(self, ddof: int) -> PyExpr: ...
def list_var(self, ddof: int) -> PyExpr: ...
def list_min(self) -> PyExpr: ...
def list_reverse(self) -> PyExpr: ...
def list_shift(self, periods: PyExpr) -> PyExpr: ...
def list_slice(self, offset: PyExpr, length: PyExpr | None = None) -> PyExpr: ...
def list_tail(self, n: PyExpr) -> PyExpr: ...
def list_sort(self, descending: bool, nulls_last: bool) -> PyExpr: ...
def list_sum(self) -> PyExpr: ...
def list_drop_nulls(self) -> PyExpr: ...
def list_sample_n(
self, n: PyExpr, with_replacement: bool, shuffle: bool, seed: int | None = None
) -> PyExpr: ...
def list_sample_fraction(
self,
fraction: PyExpr,
with_replacement: bool,
shuffle: bool,
seed: int | None = None,
) -> PyExpr: ...
def list_gather(self, index: PyExpr, null_on_oob: bool) -> PyExpr: ...
def list_gather_every(self, n: PyExpr, offset: PyExpr) -> PyExpr: ...
def list_to_array(self, width: int) -> PyExpr: ...
def list_to_struct(self, names: Sequence[str]) -> PyExpr: ...
def list_to_struct_fixed_width(self, names: Sequence[str]) -> PyExpr: ...
def list_n_unique(self) -> PyExpr: ...
def list_unique(self, maintain_order: bool) -> PyExpr: ...
def list_set_operation(self, other: PyExpr, operation: SetOperation) -> PyExpr: ...
# meta
def meta_eq(self, other: PyExpr) -> bool: ...
def meta_pop(self, schema: Schema | None = None) -> list[PyExpr]: ...
def meta_root_names(self) -> list[str]: ...
def meta_output_name(self) -> str: ...
def meta_undo_aliases(self) -> PyExpr: ...
def meta_has_multiple_outputs(self) -> bool: ...
def meta_is_column(self) -> bool: ...
def meta_is_regex_projection(self) -> bool: ...
def meta_is_column_selection(self, allow_aliasing: bool) -> bool: ...
def meta_is_literal(self, allow_aliasing: bool) -> bool: ...
def compute_tree_format(
self, display_as_dot: bool, schema: Schema | None
) -> str: ...
def meta_tree_format(self, schema: Schema | None = None) -> str: ...
def meta_show_graph(self, schema: Schema | None = None) -> str: ...
# name
def name_keep(self) -> PyExpr: ...
def name_map(self, lambda_function: Any) -> PyExpr: ...
def name_prefix(self, prefix: str) -> PyExpr: ...
def name_suffix(self, suffix: str) -> PyExpr: ...
def name_to_lowercase(self) -> PyExpr: ...
def name_to_uppercase(self) -> PyExpr: ...
def name_map_fields(self, name_mapper: Any) -> PyExpr: ...
def name_prefix_fields(self, prefix: str) -> PyExpr: ...
def name_suffix_fields(self, suffix: str) -> PyExpr: ...
def name_replace(self, pattern: str, value: str, literal: bool) -> PyExpr: ...
# rolling
def rolling_sum(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_sum_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_min(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_min_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_max(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_max_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_mean(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_mean_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_std(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
ddof: int = 1,
) -> PyExpr: ...
def rolling_std_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
ddof: int = 1,
) -> PyExpr: ...
def rolling_var(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
ddof: int = 1,
) -> PyExpr: ...
def rolling_var_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
ddof: int = 1,
) -> PyExpr: ...
def rolling_median(
self,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_median_by(
self,
by: PyExpr,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_quantile(
self,
quantile: float,
interpolation: QuantileMethod,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_quantile_by(
self,
by: PyExpr,
quantile: float,
interpolation: QuantileMethod,
window_size: str,
min_periods: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_rank(
self,
window_size: int,
method: RankMethod,
seed: int | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_rank_by(
self,
by: PyExpr,
window_size: str,
method: RankMethod,
seed: int | None,
min_samples: int,
closed: ClosedWindow,
) -> PyExpr: ...
def rolling_skew(
self,
window_size: int,
bias: bool,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_kurtosis(
self,
window_size: int,
fisher: bool,
bias: bool,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
def rolling_map(
self,
lambda_function: Any,
window_size: int,
weights: Sequence[float] | None = None,
min_periods: int | None = None,
center: bool = False,
) -> PyExpr: ...
# serde
def __getstate__(self) -> bytes: ...
def __setstate__(self, state: Any) -> None: ...
def serialize_binary(self, py_f: Any) -> None: ...
def serialize_json(self, py_f: Any) -> None: ...
@staticmethod
def deserialize_binary(py_f: Any) -> PyExpr: ...
@staticmethod
def deserialize_json(py_f: Any) -> PyExpr: ...
# string
def str_join(self, delimiter: str, ignore_nulls: bool) -> PyExpr: ...
def str_to_date(
self,
format: str | None = None,
strict: bool = True,
exact: bool = True,
cache: bool = True,
) -> PyExpr: ...
def str_to_datetime(
self,
format: str | None,
time_unit: TimeUnit | None,
time_zone: TimeZone | None,
strict: bool,
exact: bool,
cache: bool,
ambiguous: PyExpr,
) -> PyExpr: ...
def str_to_time(
self,
format: str | None = None,
strict: bool = True,
cache: bool = True,
) -> PyExpr: ...
def str_strip_chars(self, matches: PyExpr) -> PyExpr: ...
def str_strip_chars_start(self, matches: PyExpr) -> PyExpr: ...
def str_strip_chars_end(self, matches: PyExpr) -> PyExpr: ...
def str_strip_prefix(self, prefix: PyExpr) -> PyExpr: ...
def str_strip_suffix(self, suffix: PyExpr) -> PyExpr: ...
def str_slice(self, offset: PyExpr, length: PyExpr) -> PyExpr: ...
def str_head(self, n: PyExpr) -> PyExpr: ...
def str_tail(self, n: PyExpr) -> PyExpr: ...
def str_to_uppercase(self) -> PyExpr: ...
def str_to_lowercase(self) -> PyExpr: ...
def str_to_titlecase(self) -> PyExpr: ...
def str_len_bytes(self) -> PyExpr: ...
def str_len_chars(self) -> PyExpr: ...
def str_replace_n(
self, pat: PyExpr, val: PyExpr, literal: bool, n: int
) -> PyExpr: ...
def str_replace_all(self, pat: PyExpr, val: PyExpr, literal: bool) -> PyExpr: ...
def str_normalize(self, form: UnicodeForm) -> PyExpr: ...
def str_reverse(self) -> PyExpr: ...
def str_pad_start(self, length: PyExpr, fill_char: str) -> PyExpr: ...
def str_pad_end(self, length: PyExpr, fill_char: str) -> PyExpr: ...
def str_zfill(self, length: PyExpr) -> PyExpr: ...
def str_contains(
self, pat: PyExpr, literal: bool | None = None, strict: bool = True
) -> PyExpr: ...
def str_find(
self, pat: PyExpr, literal: bool | None = None, strict: bool = True
) -> PyExpr: ...
def str_ends_with(self, sub: PyExpr) -> PyExpr: ...
def str_starts_with(self, sub: PyExpr) -> PyExpr: ...
def str_hex_encode(self) -> PyExpr: ...
def str_hex_decode(self, strict: bool) -> PyExpr: ...
def str_base64_encode(self) -> PyExpr: ...
def str_base64_decode(self, strict: bool) -> PyExpr: ...
def str_to_integer(
self, base: PyExpr, dtype: Any | None = None, strict: bool = True
) -> PyExpr: ...
def str_json_decode(
self, dtype: PyDataTypeExpr | None = None, infer_schema_len: int | None = None
) -> PyExpr: ...
def str_json_path_match(self, pat: PyExpr) -> PyExpr: ...
def str_extract(self, pat: PyExpr, group_index: int) -> PyExpr: ...
def str_extract_all(self, pat: PyExpr) -> PyExpr: ...
def str_extract_groups(self, pat: str) -> PyExpr: ...
def str_count_matches(self, pat: PyExpr, literal: bool) -> PyExpr: ...
def str_split(self, by: PyExpr) -> PyExpr: ...
def str_split_inclusive(self, by: PyExpr) -> PyExpr: ...
def str_split_exact(self, by: PyExpr, n: int) -> PyExpr: ...
def str_split_exact_inclusive(self, by: PyExpr, n: int) -> PyExpr: ...
def str_splitn(self, by: PyExpr, n: int) -> PyExpr: ...
def str_to_decimal(self, scale: int) -> PyExpr: ...
def str_contains_any(
self, patterns: PyExpr, ascii_case_insensitive: bool
) -> PyExpr: ...
def str_replace_many(
self, patterns: PyExpr, replace_with: PyExpr, ascii_case_insensitive: bool
) -> PyExpr: ...
def str_extract_many(
self, patterns: PyExpr, ascii_case_insensitive: bool, overlapping: bool
) -> PyExpr: ...
def str_find_many(
self, patterns: PyExpr, ascii_case_insensitive: bool, overlapping: bool
) -> PyExpr: ...
def str_escape_regex(self) -> PyExpr: ...
@staticmethod
def str_format(f_string: str, exprs: list[PyExpr]) -> PyExpr: ...
# struct
def struct_field_by_index(self, index: int) -> PyExpr: ...
def struct_field_by_name(self, name: str) -> PyExpr: ...
def struct_multiple_fields(self, names: Sequence[str]) -> PyExpr: ...
def struct_rename_fields(self, names: Sequence[str]) -> PyExpr: ...
def struct_json_encode(self) -> PyExpr: ...
def struct_with_fields(self, fields: Sequence[PyExpr]) -> PyExpr: ...
class PyDataTypeExpr:
def __init__(self, inner: Any) -> None: ...
@staticmethod
def from_dtype(datatype: Any) -> PyDataTypeExpr: ...
@staticmethod
def of_expr(expr: PyExpr) -> PyDataTypeExpr: ...
@staticmethod
def self_dtype() -> PyDataTypeExpr: ...
def collect_dtype(self, schema: Any) -> Any: ...
def inner_dtype(self) -> PyDataTypeExpr: ...
def equals(self, other: PyDataTypeExpr) -> PyExpr: ...
def display(self) -> PyExpr: ...
def matches(self, selector: Any) -> PyExpr: ...
@staticmethod
def struct_with_fields(
fields: Sequence[tuple[str, PyDataTypeExpr]],
) -> PyDataTypeExpr: ...
def wrap_in_list(self) -> PyDataTypeExpr: ...
def wrap_in_array(self, width: int) -> PyDataTypeExpr: ...
def to_unsigned_integer(self) -> PyDataTypeExpr: ...
def to_signed_integer(self) -> PyDataTypeExpr: ...
def default_value(
self, n: int, numeric_to_one: bool, num_list_values: int
) -> PyExpr: ...
# list
def list_inner_dtype(self) -> PyDataTypeExpr: ...
# array
def arr_inner_dtype(self) -> PyDataTypeExpr: ...
def arr_width(self) -> PyExpr: ...
def arr_shape(self) -> PyExpr: ...
# struct
def struct_field_dtype_by_index(self, index: int) -> PyDataTypeExpr: ...
def struct_field_dtype_by_name(self, name: str) -> PyDataTypeExpr: ...
def struct_field_names(self) -> PyExpr: ...
class PySelector:
def __init__(self, inner: Any) -> None: ...
def union(self, other: PySelector) -> PySelector: ...
def difference(self, other: PySelector) -> PySelector: ...
def exclusive_or(self, other: PySelector) -> PySelector: ...
def intersect(self, other: PySelector) -> PySelector: ...
@staticmethod
def by_dtype(dtypes: Sequence[Any]) -> PySelector: ...
@staticmethod
def by_name(names: Sequence[str], strict: bool) -> PySelector: ...
@staticmethod
def by_index(indices: Sequence[int], strict: bool) -> PySelector: ...
@staticmethod
def first(strict: bool) -> PySelector: ...
@staticmethod
def last(strict: bool) -> PySelector: ...
@staticmethod
def matches(pattern: str) -> PySelector: ...
@staticmethod
def enum_() -> PySelector: ...
@staticmethod
def categorical() -> PySelector: ...
@staticmethod
def nested() -> PySelector: ...
@staticmethod
def list(inner_dst: PySelector | None) -> PySelector: ...
@staticmethod
def array(inner_dst: PySelector | None, width: int | None) -> PySelector: ...
@staticmethod
def struct_() -> PySelector: ...
@staticmethod
def integer() -> PySelector: ...
@staticmethod
def signed_integer() -> PySelector: ...
@staticmethod
def unsigned_integer() -> PySelector: ...
@staticmethod
def float() -> PySelector: ...
@staticmethod
def decimal() -> PySelector: ...
@staticmethod
def numeric() -> PySelector: ...
@staticmethod
def temporal() -> PySelector: ...
@staticmethod
def datetime(tu: Sequence[Any], tz: Sequence[Any]) -> PySelector: ...
@staticmethod
def duration(tu: Sequence[Any]) -> PySelector: ...
@staticmethod
def object() -> PySelector: ...
@staticmethod
def empty() -> PySelector: ...
@staticmethod
def all() -> PySelector: ...
def hash(self) -> int: ...
class PyOptFlags:
def __init__(self) -> None: ...
@staticmethod
def empty() -> PyOptFlags: ...
@staticmethod
def default() -> PyOptFlags: ...
def no_optimizations(self) -> None: ...
def copy(self) -> PyOptFlags: ...
@property
def type_coercion(self) -> bool: ...
@type_coercion.setter
def type_coercion(self, value: bool) -> None: ...
@property
def type_check(self) -> bool: ...
@type_check.setter
def type_check(self, value: bool) -> None: ...
@property
def projection_pushdown(self) -> bool: ...
@projection_pushdown.setter
def projection_pushdown(self, value: bool) -> None: ...
@property
def predicate_pushdown(self) -> bool: ...
@predicate_pushdown.setter
def predicate_pushdown(self, value: bool) -> None: ...
@property
def cluster_with_columns(self) -> bool: ...
@cluster_with_columns.setter
def cluster_with_columns(self, value: bool) -> None: ...
@property
def simplify_expression(self) -> bool: ...
@simplify_expression.setter
def simplify_expression(self, value: bool) -> None: ...
@property
def slice_pushdown(self) -> bool: ...
@slice_pushdown.setter
def slice_pushdown(self, value: bool) -> None: ...
@property
def comm_subplan_elim(self) -> bool: ...
@comm_subplan_elim.setter
def comm_subplan_elim(self, value: bool) -> None: ...
@property
def comm_subexpr_elim(self) -> bool: ...
@comm_subexpr_elim.setter
def comm_subexpr_elim(self, value: bool) -> None: ...
@property
def check_order_observe(self) -> bool: ...
@check_order_observe.setter
def check_order_observe(self, value: bool) -> None: ...
@property
def fast_projection(self) -> bool: ...
@fast_projection.setter
def fast_projection(self, value: bool) -> None: ...
@property
def eager(self) -> bool: ...
@eager.setter
def eager(self, value: bool) -> None: ...
@property
def streaming(self) -> bool: ...
@streaming.setter
def streaming(self, value: bool) -> None: ...
class PyPartitioning:
def __init__(self) -> None: ...
base_path: Any
@staticmethod
def new_max_size(
base_path: Any,
file_path_cb: Any | None,
max_size: int,
per_partition_sort_by: Sequence[PyExpr] | None,
finish_callback: Any | None,
) -> PyPartitioning: ...
@staticmethod
def new_by_key(
base_path: Any,
file_path_cb: Any | None,
by: Sequence[PyExpr],
include_key: bool,
per_partition_sort_by: Sequence[PyExpr] | None,
finish_callback: Any | None,
) -> PyPartitioning: ...
@staticmethod
def new_parted(
base_path: Any,
file_path_cb: Any | None,
by: Sequence[PyExpr],
include_key: bool,
per_partition_sort_by: Sequence[PyExpr] | None,
finish_callback: Any | None,
) -> PyPartitioning: ...
# functions.lazy
def rolling_corr(
x: PyExpr, y: PyExpr, window_size: int, min_periods: int, ddof: int
) -> PyExpr: ...
def rolling_cov(
x: PyExpr, y: PyExpr, window_size: int, min_periods: int, ddof: int
) -> PyExpr: ...
def arg_sort_by(
by: Sequence[PyExpr],
descending: Sequence[bool],
nulls_last: Sequence[bool],
multithreaded: bool,
maintain_order: bool,
) -> PyExpr: ...
def arg_where(condition: PyExpr) -> PyExpr: ...
def as_struct(exprs: Sequence[PyExpr]) -> PyExpr: ...
def field(names: Sequence[str]) -> PyExpr: ...
def coalesce(exprs: Sequence[PyExpr]) -> PyExpr: ...
def col(name: str) -> PyExpr: ...
def element() -> PyExpr: ...
def collect_all(
lfs: Sequence[PyLazyFrame], engine: Any, optflags: PyOptFlags
) -> list[PyDataFrame]: ...
def explain_all(lfs: Sequence[PyLazyFrame], optflags: PyOptFlags) -> str: ...
def collect_all_with_callback(
lfs: Sequence[PyLazyFrame], engine: Any, optflags: PyOptFlags, lambda_func: Any
) -> None: ...
def concat_lf(
seq: Any, rechunk: bool, parallel: bool, to_supertypes: bool, maintain_order: bool
) -> PyLazyFrame: ...
def concat_list(s: Sequence[PyExpr]) -> PyExpr: ...
def concat_arr(s: Sequence[PyExpr]) -> PyExpr: ...
def concat_str(s: Sequence[PyExpr], separator: str, ignore_nulls: bool) -> PyExpr: ...
def len() -> PyExpr: ...
def cov(a: PyExpr, b: PyExpr, ddof: int) -> PyExpr: ...
def arctan2(y: PyExpr, x: PyExpr) -> PyExpr: ...
def cum_fold(
acc: PyExpr,
lambda_func: Any,
exprs: Sequence[PyExpr],
returns_scalar: bool,
return_dtype: PyDataTypeExpr | None,
include_init: bool,
) -> PyExpr: ...
def cum_reduce(
lambda_func: Any,
exprs: Sequence[PyExpr],
returns_scalar: bool,
return_dtype: PyDataTypeExpr | None,
) -> PyExpr: ...
def datetime(
year: PyExpr,
month: PyExpr,
day: PyExpr,
hour: PyExpr | None,
minute: PyExpr | None,
second: PyExpr | None,
microsecond: PyExpr | None,
time_unit: TimeUnit, # Default set by Rust code
time_zone: TimeZone | None, # Default set by Rust code
ambiguous: PyExpr, # Default set by Rust code
) -> PyExpr: ...
def concat_lf_diagonal(
lfs: Any, rechunk: bool, parallel: bool, to_supertypes: bool, maintain_order: bool
) -> PyLazyFrame: ...
def concat_lf_horizontal(
lfs: Any,
parallel: bool,
) -> PyLazyFrame: ...
def concat_expr(e: Sequence[PyExpr], rechunk: bool) -> PyExpr: ...
def duration(
weeks: PyExpr | None,
days: PyExpr | None,
hours: PyExpr | None,
minutes: PyExpr | None,
seconds: PyExpr | None,
milliseconds: PyExpr | None,
microseconds: PyExpr | None,
nanoseconds: PyExpr | None,
time_unit: TimeUnit, # Default set by Rust code
) -> PyExpr: ...
def fold(
acc: PyExpr,
lambda_func: Any,
exprs: Sequence[PyExpr],
returns_scalar: bool,
return_dtype: PyDataTypeExpr | None,
) -> PyExpr: ...
def lit(value: Any, allow_object: bool, is_scalar: bool) -> PyExpr: ...
def map_expr(
pyexpr: Sequence[PyExpr],
lambda_func: Any,
output_type: PyDataTypeExpr | None,
is_elementwise: bool,
returns_scalar: bool,
) -> PyExpr: ...
def pearson_corr(a: PyExpr, b: PyExpr) -> PyExpr: ...
def reduce(
lambda_func: Any,
exprs: Sequence[PyExpr],
returns_scalar: bool,
return_dtype: PyDataTypeExpr | None,
) -> PyExpr: ...
def repeat(value: PyExpr, n: PyExpr, dtype: Any | None = None) -> PyExpr: ...
def spearman_rank_corr(a: PyExpr, b: PyExpr, propagate_nans: bool) -> PyExpr: ...
def sql_expr(sql: str) -> PyExpr: ...
# functions.aggregations
def all_horizontal(exprs: Sequence[PyExpr]) -> PyExpr: ...
def any_horizontal(exprs: Sequence[PyExpr]) -> PyExpr: ...
def max_horizontal(exprs: Sequence[PyExpr]) -> PyExpr: ...
def min_horizontal(exprs: Sequence[PyExpr]) -> PyExpr: ...
def sum_horizontal(exprs: Sequence[PyExpr], ignore_nulls: bool) -> PyExpr: ...
def mean_horizontal(exprs: Sequence[PyExpr], ignore_nulls: bool) -> PyExpr: ...
# functions.business
def business_day_count(
start: PyExpr,
end: PyExpr,
week_mask: Sequence[bool],
holidays: Sequence[int],
) -> PyExpr: ...
# functions.eager
def concat_df(dfs: Any) -> PyDataFrame: ...
def concat_series(series: Any) -> PySeries: ...
def concat_df_diagonal(dfs: Any) -> PyDataFrame: ...
def concat_df_horizontal(dfs: Any) -> PyDataFrame: ...
# functions.io
def read_ipc_schema(py_f: Any) -> dict[str, Any]: ...
def read_parquet_metadata(
py_f: Any, storage_options: Any, credential_provider: Any, retries: int
) -> dict[str, str]: ...
def read_clipboard_string() -> str: ...
def write_clipboard_string(s: str) -> None: ...
# functions.meta
def get_index_type() -> Any: ...
def thread_pool_size() -> int: ...
def set_float_fmt(fmt: FloatFmt) -> None: ...
def get_float_fmt() -> str: ...
def set_float_precision(precision: int | None) -> None: ...
def get_float_precision() -> int | None: ...
def set_thousands_separator(sep: str | None) -> None: ...
def get_thousands_separator() -> str | None: ...
def set_decimal_separator(sep: str | None) -> None: ...
def get_decimal_separator() -> str | None: ...
def set_trim_decimal_zeros(trim: bool | None) -> None: ...
def get_trim_decimal_zeros() -> bool | None: ...
# functions.misc
def dtype_str_repr(dtype: Any) -> str: ...
def register_plugin_function(
plugin_path: str,
function_name: str,
args: Sequence[PyExpr],
kwargs: Sequence[int],
is_elementwise: bool,
input_wildcard_expansion: bool,
returns_scalar: bool,
cast_to_supertype: bool,
pass_name_to_apply: bool,
changes_length: bool,
) -> PyExpr: ...
def __register_startup_deps() -> None: ...
# functions.random
def set_random_seed(seed: int) -> None: ...
# functions.range
def int_range(
start: PyExpr, end: PyExpr, step: int, dtype: PyDataTypeExpr
) -> PyExpr: ...
def eager_int_range(
lower: Any, upper: Any, step: Any, dtype: PyDataTypeExpr
) -> PySeries: ...
def int_ranges(
start: PyExpr, end: PyExpr, step: PyExpr, dtype: PyDataTypeExpr
) -> PyExpr: ...
def date_range(
start: PyExpr, end: PyExpr, interval: str, closed: ClosedWindow
) -> PyExpr: ...
def date_ranges(
start: PyExpr, end: PyExpr, interval: str, closed: ClosedWindow
) -> PyExpr: ...
def datetime_range(
start: PyExpr,
end: PyExpr,
every: str,
closed: ClosedWindow,
time_unit: TimeUnit | None,
time_zone: TimeZone | None,
) -> PyExpr: ...
def datetime_ranges(
start: PyExpr,
end: PyExpr,
every: str,
closed: ClosedWindow,
time_unit: TimeUnit | None,
time_zone: TimeZone | None,
) -> PyExpr: ...
def time_range(
start: PyExpr, end: PyExpr, every: str, closed: ClosedWindow
) -> PyExpr: ...
def time_ranges(
start: PyExpr, end: PyExpr, every: str, closed: ClosedWindow
) -> PyExpr: ...
def linear_space(
start: PyExpr, end: PyExpr, num_samples: PyExpr, closed: ClosedInterval
) -> PyExpr: ...
def linear_spaces(
start: PyExpr,
end: PyExpr,
num_samples: PyExpr,
closed: ClosedInterval,
as_array: bool,
) -> PyExpr: ...
# functions.string_cache
class PyStringCacheHolder: ...
def enable_string_cache() -> None: ...
def disable_string_cache() -> None: ...
def using_string_cache() -> bool: ...
# functions.strings
def escape_regex(s: str) -> str: ...
# functions.strings
def check_length(check: bool) -> None: ...
def get_engine_affinity() -> EngineType: ...
# functions.when
class PyWhen:
def then(self, statement: PyExpr) -> PyThen: ...
class PyThen:
def when(self, condition: PyExpr) -> PyChainedWhen: ...
def otherwise(self, statement: PyExpr) -> PyExpr: ...
class PyChainedWhen:
def then(self, statement: PyExpr) -> PyChainedThen: ...
class PyChainedThen:
def when(self, condition: PyExpr) -> PyChainedWhen: ...
def otherwise(self, statement: PyExpr) -> PyExpr: ...
def when(condition: PyExpr) -> PyWhen: ...
# functions: schema
def init_polars_schema_from_arrow_c_schema(
polars_schema: Any, schema_object: Any
) -> None: ...
def polars_schema_field_from_arrow_c_schema(schema_object: Any) -> tuple[Any, Any]: ...
def polars_schema_to_pycapsule(schema: Schema, compat_level: CompatLevel) -> Any: ...
class PyLazyGroupBy:
def agg(self, aggs: list[PyExpr]) -> PyLazyFrame: ...
def head(self, n: int) -> PyLazyFrame: ...
def tail(self, n: int) -> PyLazyFrame: ...
def map_groups(
self, lambda_function: Any, schema: Schema | None
) -> PyLazyFrame: ...
# categorical
class PyCategories:
def __init__(self, name: str, namespace: str, physical: str) -> None: ...
@staticmethod
def global_categories() -> PyCategories: ...
@staticmethod
def random(namespace: str, physical: str) -> PyCategories: ...
def __eq__(self, other: PyCategories) -> bool: ... # type: ignore[override]
def __hash__(self) -> int: ...
def name(self) -> str: ...
def namespace(self) -> str: ...
def physical(self) -> str: ...
def get_cat(self, s: str) -> int | None: ...
def cat_to_str(self, cat: int) -> str | None: ...
def is_global(self) -> bool: ...
class PyBatchedCsv:
@staticmethod
def new(
infer_schema_length: int | None,
chunk_size: int,
has_header: bool,
ignore_errors: bool,
n_rows: int | None,
skip_rows: int,
skip_lines: int,
projection: Sequence[int] | None,
separator: str,
rechunk: bool,
columns: Sequence[str] | None,
encoding: CsvEncoding,
n_threads: int | None,
path: Any,
schema_overrides: Sequence[tuple[str, DataType]] | None,
overwrite_dtype_slice: Sequence[DataType] | None,
low_memory: bool,
comment_prefix: str | None,
quote_char: str | None,
null_values: NullValues | None,
missing_utf8_is_empty_string: bool,
try_parse_dates: bool,
skip_rows_after_header: int,
row_index: tuple[str, int] | None,
eol_char: str,
raise_if_empty: bool,
truncate_ragged_lines: bool,
decimal_comma: bool,
) -> PyBatchedCsv: ...
def next_batches(self, n: int) -> list[PyDataFrame] | None: ...
# catalog
class PyCatalogClient:
@staticmethod
def new(workspace_url: str, bearer_token: str | None) -> PyCatalogClient: ...
def list_catalogs(self) -> list[Any]: ...
def list_namespaces(self, catalog_name: str) -> list[Any]: ...
def list_tables(self, catalog_name: str, namespace: str) -> list[Any]: ...
def get_table_info(
self, table_name: str, catalog_name: str, namespace: str
) -> Any: ...
def get_table_credentials(
self, table_id: str, write: bool
) -> tuple[Any, Any, Any]: ...
def scan_table(
self,
catalog_name: str,
namespace: str,
table_name: str,
cloud_options: dict[str, str] | None,
credential_provider: Any | None,
retries: int,
) -> PyLazyFrame: ...
def create_catalog(
self, catalog_name: str, comment: str | None, storage_root: str | None
) -> Any: ...
def delete_catalog(self, catalog_name: str, force: bool) -> None: ...
def create_namespace(
self,
catalog_name: str,
namespace: str,
comment: str | None,
storage_root: str | None,
) -> Any: ...
def delete_namespace(
self, catalog_name: str, namespace: str, force: bool
) -> None: ...
def create_table(
self,
catalog_name: str,
namespace: str,
table_name: str,
schema: Any | None,
table_type: str,
data_source_format: str | None,
comment: str | None,
storage_root: str | None,
properties: Sequence[tuple[str, str]],
) -> Any: ...
def delete_table(
self, catalog_name: str, namespace: str, table_name: str
) -> None: ...
@staticmethod
def type_json_to_polars_type(type_json: str) -> Any: ...
@staticmethod
def init_classes(
catalog_info_cls: Any,
namespace_info_cls: Any,
table_info_cls: Any,
column_info_cls: Any,
) -> None: ...
# sql
class PySQLContext:
@staticmethod
def new() -> PySQLContext: ...
def execute(self, query: str) -> PyLazyFrame: ...
def get_tables(self) -> list[str]: ...
def register(self, name: str, lf: PyLazyFrame) -> None: ...
def unregister(self, name: str) -> None: ...
# testing
def assert_series_equal_py(
left: PySeries,
right: PySeries,
*,
check_dtypes: bool,
check_names: bool,
check_order: bool,
check_exact: bool,
rel_tol: float,
abs_tol: float,
categorical_as_str: bool,
) -> None: ...
def assert_dataframe_equal_py(
left: PyDataFrame,
right: PyDataFrame,
*,
check_row_order: bool,
check_column_order: bool,
check_dtypes: bool,
check_exact: bool,
rel_tol: float,
abs_tol: float,
categorical_as_str: bool,
) -> None: ...
# datatypes
def _get_dtype_max(dt: DataType) -> PyExpr: ...
def _get_dtype_min(dt: DataType) -> PyExpr: ...
def _known_timezones() -> list[str]: ...
# cloud_client
def prepare_cloud_plan(
lf: PyLazyFrame,
*,
allow_local_scans: bool,
) -> bytes: ...
# cloud_server
def _execute_ir_plan_with_gpu(ir_plan_ser: Sequence[int]) -> PyDataFrame: ...
# visit
class PyExprIR:
node: int
output_name: str
class NodeTraverser:
def get_exprs(self) -> list[PyExprIR]: ...
def get_inputs(self) -> list[int]: ...
def version(self) -> tuple[int, int]: ...
def get_schema(self) -> dict[str, DataType]: ...
def get_dtype(self, expr_node: int) -> DataType: ...
def set_node(self, node: int) -> None: ...
def get_node(self) -> int: ...
def set_udf(self, function: Any, is_pure: bool = False) -> None: ...
def view_current_node(self) -> Any: ...
def view_expression(self, node: int) -> Any: ...
def add_expressions(self, expressions: list[PyExpr]) -> tuple[list[int], int]: ...
def set_expr_mapping(self, mapping: list[int]) -> None: ...
def unset_expr_mapping(self) -> None: ...
Reference in New Issue View Git Blame Copy Permalink