polars-runtime-compat 1.34.0b3__cp39-abi3-macosx_11_0_arm64.whl → 1.34.0b5__cp39-abi3-macosx_11_0_arm64.whl

polars/_plr.pyi

@@ -1,2496 +0,0 @@
-from collections.abc import Callable, Sequence
-from typing import Any, Literal, overload
-
-from numpy.typing import NDArray
-from typing_extensions import TypeAlias
-
-# 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: PyScanOptions,
-        parallel: Any,
-        low_memory: bool,
-        use_statistics: bool,
-    ) -> PyLazyFrame: ...
-    @staticmethod
-    def new_from_ipc(
-        source: Any | None,
-        sources: Any,
-        n_rows: int | None,
-        cache: bool,
-        rechunk: bool,
-        row_index: tuple[str, int] | None,
-        cloud_options: dict[str, Any] | None,
-        credential_provider: Any | None,
-        hive_partitioning: bool | None,
-        hive_schema: Any | None,
-        try_parse_hive_dates: bool,
-        retries: int,
-        file_cache_ttl: int | None,
-        include_file_paths: str | 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) -> PyLazyFrame: ...
-    def count(self) -> PyLazyFrame: ...
-    def merge_sorted(self, other: PyLazyFrame, key: str) -> 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 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 = False) -> PyExpr: ...
-    def arr_shift(self, n: PyExpr) -> PyExpr: ...
-    def arr_explode(self) -> 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) -> PyExpr: ...
-    def dt_total_hours(self) -> PyExpr: ...
-    def dt_total_minutes(self) -> PyExpr: ...
-    def dt_total_seconds(self) -> PyExpr: ...
-    def dt_total_milliseconds(self) -> PyExpr: ...
-    def dt_total_microseconds(self) -> PyExpr: ...
-    def dt_total_nanoseconds(self) -> 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_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: ...
-
-    # 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_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: ...
-
-    # 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 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
-) -> 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
-) -> 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) -> 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: ...