from collections.abc import Callable, Sequence from typing import Any, Literal, TypeAlias, overload from numpy.typing import NDArray from polars._typing import ArrowSchemaExportable from polars.io.iceberg._sink import IcebergSinkState 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 = Any 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] 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: ... def ext_to(self, dtype: DataType) -> PySeries: ... def ext_storage(self) -> PySeries: ... def set(self, mask: PySeries, value: PySeries) -> 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 | Sequence[float], interpolation: QuantileMethod ) -> Any: ... def std(self, ddof: int) -> Any: ... def var(self, ddof: int) -> Any: ... def sum(self) -> Any: ... def first(self, ignore_nulls: bool) -> Any: ... def last(self, ignore_nulls: bool) -> 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_f16(self, other: float) -> 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_f16(self, other: float) -> 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_f16(self, other: float) -> 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_f16(self, other: float) -> 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_f16(self, other: float) -> 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_f16_rhs(self, other: float) -> 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_f16_rhs(self, other: float) -> 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_f16_rhs(self, other: float) -> 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_f16_rhs(self, other: float) -> 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_f16_rhs(self, other: float) -> 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_u128(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_f16(self, rhs: float) -> 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_u128(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_f16(self, rhs: float) -> 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_u128(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_f16(self, rhs: float) -> 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_u128(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_f16(self, rhs: float) -> 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_f16(self, rhs: float) -> 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_u128(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_f16(self, rhs: float) -> 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_f16(name: str, array: NDArray1D, nan_is_null: 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_f16(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 new_ext(name: str, values: Any, strict: bool, dtype: DataType) -> 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: ... @staticmethod def empty_with_height(height: int) -> PyDataFrame: ... 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] | None, index: Sequence[str], value_name: str | None, variable_name: 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, ) -> 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, include_file_paths: str | None, missing_columns: 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, record_batch_statistics: bool | None, scan_options: ScanOptions, ) -> PyLazyFrame: ... @staticmethod def new_from_scan_lines( sources: Any, *, name: str, scan_options: ScanOptions, ) -> PyLazyFrame: ... @staticmethod def new_from_expand_paths( sources: Any, *, name: str, scan_options: ScanOptions, ) -> 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 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 collect_batches( self, engine: Any, maintain_order: bool, chunk_size: int | None, lazy: bool ) -> PyCollectBatches: ... def sink_parquet( self, target: SinkTarget, sink_options: Any, compression: str, compression_level: int | None, statistics: StatisticsOptions, row_group_size: int | None, data_page_size: int | None, metadata: KeyValueMetadata | None, arrow_schema: ArrowSchemaExportable | None = None, ) -> PyLazyFrame: ... def sink_ipc( self, target: SinkTarget, sink_options: Any, compression: IpcCompression | None, compat_level: CompatLevel, record_batch_size: int | None, record_batch_statistics: bool | None, ) -> PyLazyFrame: ... def sink_csv( self, target: SinkTarget, sink_options: Any, include_bom: bool, compression: Literal["uncompressed", "gzip", "zstd"], compression_level: int | None, check_extension: 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, ) -> PyLazyFrame: ... def sink_ndjson( self, target: SinkTarget, compression: Literal["uncompressed", "gzip", "zstd"], compression_level: int | None, check_extension: bool, sink_options: Any, ) -> PyLazyFrame: ... def sink_batches( self, function: Callable[[PyDataFrame], bool], maintain_order: bool, chunk_size: int | None, ) -> PyLazyFrame: ... def sink_iceberg(self, sink_state_obj: IcebergSinkState) -> 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, *, empty_as_null: bool, keep_nulls: bool ) -> PyLazyFrame: ... def null_count(self) -> PyLazyFrame: ... def unique( self, maintain_order: bool, subset: list[PyExpr] | 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 pivot( self, on: PySelector, on_columns: PyDataFrame, index: PySelector, values: PySelector, agg: PyExpr, maintain_order: bool, separator: str, column_naming: Literal["auto", "combine"], ) -> PyLazyFrame: ... def unpivot( self, on: PySelector | None, 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, maintain_order: bool ) -> 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 min_by(self, other: PyExpr) -> PyExpr: ... def max(self) -> PyExpr: ... def max_by(self, other: PyExpr) -> 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, ignore_nulls: bool) -> PyExpr: ... def last(self, ignore_nulls: bool) -> PyExpr: ... def item(self, *, allow_empty: bool) -> PyExpr: ... def implode(self, maintain_order: bool) -> 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, *, null_on_oob: bool = False, ) -> 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, *, empty_as_null: bool, keep_nulls: bool) -> 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 truncate(self, decimals: 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: PyExpr, 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 | None, dtype: DataType | None) -> PyExpr: ... def mode(self, *, maintain_order: bool) -> 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, nulls_last: bool | None) -> 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_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, *, empty_as_null: bool, keep_nulls: bool) -> 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: ... def bin_slice(self, offset: PyExpr, length: PyExpr) -> PyExpr: ... def bin_head(self, n: PyExpr) -> PyExpr: ... def bin_tail(self, n: PyExpr) -> PyExpr: ... def bin_get(self, index: PyExpr, null_on_oob: bool) -> 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: PyExpr, 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: PyExpr ) -> 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_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: ... def meta_replace_element(self, expr: PyExpr) -> PyExpr: ... # 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_split_regex(self, by: PyExpr, strict: bool) -> PyExpr: ... def str_split_regex_inclusive(self, by: PyExpr, strict: bool) -> 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, leftmost: bool, ) -> PyExpr: ... def str_extract_many( self, patterns: PyExpr, ascii_case_insensitive: bool, overlapping: bool, leftmost: bool, ) -> PyExpr: ... def str_find_many( self, patterns: PyExpr, ascii_case_insensitive: bool, overlapping: bool, leftmost: 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: ... # extension def ext_to(self, dtype: PyDataTypeExpr) -> PyExpr: ... def ext_storage(self) -> 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, expand_patterns: 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 sort_collapse(self) -> bool: ... @sort_collapse.setter def sort_collapse(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: ... # 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_lazy( lfs: Sequence[PyLazyFrame], optflags: PyOptFlags ) -> PyLazyFrame: ... 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, strict: bool = False, ) -> 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: PyExpr, ) -> 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, strict: bool = False) -> 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 ) -> 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: ... def gen_uuid_v7() -> bytes: ... # 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: other def check_length(check: bool) -> None: ... def get_engine_affinity() -> EngineType: ... def config_reload_env_vars() -> None: ... def config_reload_env_var(var: str) -> None: ... # 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 having(self, predicates: list[PyExpr]) -> PyLazyGroupBy: ... 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: ... # 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, ) -> 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: ... @staticmethod def table_identifiers( query: str, include_schema: bool = ..., unique: bool = ..., ) -> list[str]: ... # 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: ... def assert_schema_equal_py( left: Schema, right: Schema, *, check_column_order: bool, check_dtypes: bool, ) -> None: ... # datatypes def _get_dtype_max(dt: DataType) -> PyExpr: ... def _get_dtype_min(dt: DataType) -> PyExpr: ... def _known_timezones() -> list[str]: ... # extension def _register_extension_type(name: str, cls: Any | None) -> None: ... def _unregister_extension_type(name: str) -> None: ... # 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: ... class PyCollectBatches: def start(self) -> None: ... # Export def __arrow_c_stream__(self, requested_schema: object | None = None) -> object: ...