Generated interface inventory (Polars parity)
This file is generated from stubs/source. It inventories PlanFrame methods and attempts to show parent-interface signatures when available in the local environment.
Core Frame vs polars.LazyFrame
| Method | Our signature | Parent | Parent signature | Status | Notes |
|---|---|---|---|---|---|
__init__ |
def __init__( |
polars.LazyFrame |
(self, data: 'FrameInitTypes | None' = None, schema: 'SchemaDefinition | None' = None, *, schema_overrides: 'SchemaDict | None' = None, strict: 'bool' = True, orient: 'Orientation | None' = None, infer_schema_length: 'int | None' = 100, nan_to_null: 'bool' = False, height: 'int | None' = None) -> 'None' |
typed-parity | — |
cache |
def cache(self) -> NoReturn |
polars.LazyFrame |
(self) -> 'LazyFrame' |
typed-parity | — |
cast |
def cast(self, name: LiteralString, dtype: type[T]) -> Self |
polars.LazyFrame |
(self, dtypes: 'Mapping[ColumnNameOrSelector | PolarsDataType, PolarsDataType | PythonDataType] | PolarsDataType | pl.DataTypeExpr | Schema', *, strict: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
cast_many |
def cast_many(self, mapping: Mapping[LiteralString, object], *, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
cast_subset |
def cast_subset(self, *columns: LiteralString, dtype: object, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
clip |
def clip( |
polars.LazyFrame |
— | typed-parity | — |
collect |
def collect(self, *, options: ExecutionOptions | None = ...) -> BackendFrameT |
polars.LazyFrame |
(self, *, type_coercion: 'bool' = True, predicate_pushdown: 'bool' = True, projection_pushdown: 'bool' = True, simplify_expression: 'bool' = True, slice_pushdown: 'bool' = True, comm_subplan_elim: 'bool' = True, comm_subexpr_elim: 'bool' = True, cluster_with_columns: 'bool' = True, collapse_joins: 'bool' = True, no_optimization: 'bool' = False, engine: 'EngineType' = 'auto', background: 'bool' = False, optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>, **_kwargs: 'Any') -> 'DataFrame | InProcessQuery' |
typed-parity | — |
drop |
def drop(self, __c1: LiteralString, *, strict: bool = True) -> Self |
polars.LazyFrame |
(self, *columns: 'ColumnNameOrSelector | Iterable[ColumnNameOrSelector]', strict: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
drop_duplicates |
def drop_duplicates( |
polars.LazyFrame |
— | typed-parity | — |
drop_nulls |
def drop_nulls( |
polars.LazyFrame |
(self, subset: 'ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None' = None) -> 'LazyFrame' |
typed-parity | — |
drop_nulls_all |
def drop_nulls_all(self, *subset: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
drop_prefix |
def drop_prefix(self, prefix: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
drop_regex |
def drop_regex(self, pattern: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
drop_suffix |
def drop_suffix(self, suffix: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
duplicated |
def duplicated( |
polars.LazyFrame |
— | typed-parity | — |
explain |
def explain(self, *_: object, **__: object) -> NoReturn |
polars.LazyFrame |
(self, *, format: 'ExplainFormat' = 'plain', optimized: 'bool' = True, type_coercion: 'bool' = True, predicate_pushdown: 'bool' = True, projection_pushdown: 'bool' = True, simplify_expression: 'bool' = True, slice_pushdown: 'bool' = True, comm_subplan_elim: 'bool' = True, comm_subexpr_elim: 'bool' = True, cluster_with_columns: 'bool' = True, collapse_joins: 'bool' = True, streaming: 'bool' = False, engine: 'EngineType' = 'auto', tree_format: 'bool | None' = None, optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'str' |
typed-parity | — |
explode |
def explode( |
polars.LazyFrame |
(self, columns: 'ColumnNameOrSelector | Iterable[ColumnNameOrSelector]', *more_columns: 'ColumnNameOrSelector', empty_as_null: 'bool' = True, keep_nulls: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
fill_null |
def fill_null(self, value: Scalar, *subset: LiteralString) -> Self |
polars.LazyFrame |
(self, value: 'Any | Expr | None' = None, strategy: 'FillNullStrategy | None' = None, limit: 'int | None' = None, *, matches_supertype: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
fill_null_many |
def fill_null_many( |
polars.LazyFrame |
— | typed-parity | — |
fill_null_subset |
def fill_null_subset( |
polars.LazyFrame |
— | typed-parity | — |
filter |
def filter(self, *predicates: Expr[bool]) -> Self |
polars.LazyFrame |
(self, *predicates: 'IntoExprColumn | Iterable[IntoExprColumn] | bool | list[bool] | np.ndarray[Any, Any]', **constraints: 'Any') -> 'LazyFrame' |
typed-parity | — |
group_by |
def group_by( |
polars.LazyFrame |
(self, *by: 'IntoExpr | Iterable[IntoExpr]', maintain_order: 'bool' = False, **named_by: 'IntoExpr') -> 'LazyGroupBy' |
typed-parity | — |
group_by_dynamic |
def group_by_dynamic( |
polars.LazyFrame |
(self, index_column: 'IntoExpr', *, every: 'str | timedelta', period: 'str | timedelta | None' = None, offset: 'str | timedelta | None' = None, include_boundaries: 'bool' = False, closed: 'ClosedInterval' = 'left', label: 'Label' = 'left', group_by: 'IntoExpr | Iterable[IntoExpr] | None' = None, start_by: 'StartBy' = 'window') -> 'LazyGroupBy' |
typed-parity | — |
head |
def head(self, n: int) -> Self |
polars.LazyFrame |
(self, n: 'int' = 5) -> 'LazyFrame' |
typed-parity | — |
hstack |
def hstack(self, other: Frame[SchemaT, BackendFrameT, BackendExprT]) -> Self |
polars.LazyFrame |
— | typed-parity | — |
join |
def join( |
polars.LazyFrame |
(self, other: 'LazyFrame', on: 'str | Expr | Sequence[str | Expr] | None' = None, how: 'JoinStrategy' = 'inner', *, left_on: 'str | Expr | Sequence[str | Expr] | None' = None, right_on: 'str | Expr | Sequence[str | Expr] | None' = None, suffix: 'str' = '_right', validate: 'JoinValidation' = 'm:m', nulls_equal: 'bool' = False, coalesce: 'bool | None' = None, maintain_order: 'MaintainOrderJoin | None' = None, allow_parallel: 'bool' = True, force_parallel: 'bool' = False) -> 'LazyFrame' |
typed-parity | — |
limit |
def limit(self, n: int) -> Self |
polars.LazyFrame |
(self, n: 'int' = 5) -> 'LazyFrame' |
typed-parity | — |
map_batches |
def map_batches(self, *_: object, **__: object) -> NoReturn |
polars.LazyFrame |
(self, function: 'Callable[[DataFrame], DataFrame]', *, predicate_pushdown: 'bool' = True, projection_pushdown: 'bool' = True, slice_pushdown: 'bool' = True, no_optimizations: 'bool' = False, schema: 'None | SchemaDict' = None, validate_output_schema: 'bool' = True, streamable: 'bool' = False) -> 'LazyFrame' |
typed-parity | — |
materialize_model |
def materialize_model( |
polars.LazyFrame |
— | typed-parity | — |
move |
def move( |
polars.LazyFrame |
— | typed-parity | — |
optimize |
def optimize(self, *, level: Literal[0, 1, 2] = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
pipe |
def pipe(self, *_: object, **__: object) -> NoReturn |
polars.LazyFrame |
(self, function: 'Callable[Concatenate[LazyFrame, P], T]', *args: 'P.args', **kwargs: 'P.kwargs') -> 'T' |
typed-parity | — |
pivot |
def pivot( |
polars.LazyFrame |
(self, on: 'ColumnNameOrSelector | Sequence[ColumnNameOrSelector]', on_columns: 'Sequence[Any] | pl.Series | pl.DataFrame', *, index: 'ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None' = None, values: 'ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None' = None, aggregate_function: 'PivotAgg | Expr | None' = None, maintain_order: 'bool' = False, separator: 'str' = '_', column_naming: "Literal['auto', 'combine']" = 'auto') -> 'LazyFrame' |
typed-parity | — |
pivot_longer |
def pivot_longer( |
polars.LazyFrame |
— | typed-parity | — |
pivot_wider |
def pivot_wider( |
polars.LazyFrame |
— | typed-parity | — |
plan |
def plan(self) -> PlanNode |
polars.LazyFrame |
— | typed-parity | — |
posexplode |
def posexplode( |
polars.LazyFrame |
— | typed-parity | — |
profile |
def profile(self, *_: object, **__: object) -> NoReturn |
polars.LazyFrame |
(self, *, type_coercion: 'bool' = True, predicate_pushdown: 'bool' = True, projection_pushdown: 'bool' = True, simplify_expression: 'bool' = True, no_optimization: 'bool' = False, slice_pushdown: 'bool' = True, comm_subplan_elim: 'bool' = True, comm_subexpr_elim: 'bool' = True, cluster_with_columns: 'bool' = True, collapse_joins: 'bool' = True, show_plot: 'bool' = False, truncate_nodes: 'int' = 0, figsize: 'tuple[int, int]' = (18, 8), engine: 'EngineType' = 'auto', optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>, **_kwargs: 'Any') -> 'tuple[DataFrame, DataFrame]' |
typed-parity | — |
rename |
def rename( |
polars.LazyFrame |
(self, mapping: 'Mapping[str, str] | Callable[[str], str]', *, strict: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
rename_lower |
def rename_lower(self, *subset: LiteralString, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rename_prefix |
def rename_prefix(self, prefix: str, *subset: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rename_replace |
def rename_replace(self, old: str, new: str, *subset: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rename_strip |
def rename_strip( |
polars.LazyFrame |
— | typed-parity | — |
rename_suffix |
def rename_suffix(self, suffix: str, *subset: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rename_title |
def rename_title(self, *subset: LiteralString, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rename_upper |
def rename_upper(self, *subset: LiteralString, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
reorder_columns |
def reorder_columns(self, __c1: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
rolling_agg |
def rolling_agg( |
polars.LazyFrame |
— | typed-parity | — |
sample |
def sample( |
polars.LazyFrame |
— | typed-parity | — |
schema |
def schema(self) -> Schema |
polars.LazyFrame |
— | typed-parity | — |
select |
def select(self, __c1: LiteralString) -> Self |
polars.LazyFrame |
(self, *exprs: 'IntoExpr | Iterable[IntoExpr]', **named_exprs: 'IntoExpr') -> 'LazyFrame' |
typed-parity | — |
select_exclude |
def select_exclude(self, __c1: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_first |
def select_first(self, __c1: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_last |
def select_last(self, __c1: LiteralString) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_prefix |
def select_prefix(self, prefix: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_regex |
def select_regex(self, pattern: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_schema |
def select_schema(self, selector: ColumnSelector, *, strict: bool = ...) -> Self |
polars.LazyFrame |
— | typed-parity | — |
select_suffix |
def select_suffix(self, suffix: str) -> Self |
polars.LazyFrame |
— | typed-parity | — |
show_graph |
def show_graph(self, *_: object, **__: object) -> NoReturn |
polars.LazyFrame |
(self, *, optimized: 'bool' = True, show: 'bool' = True, output_path: 'str | Path | None' = None, raw_output: 'bool' = False, figsize: 'tuple[float, float]' = (16.0, 12.0), type_coercion: 'bool' = True, _type_check: 'bool' = True, predicate_pushdown: 'bool' = True, projection_pushdown: 'bool' = True, simplify_expression: 'bool' = True, slice_pushdown: 'bool' = True, comm_subplan_elim: 'bool' = True, comm_subexpr_elim: 'bool' = True, cluster_with_columns: 'bool' = True, collapse_joins: 'bool' = True, engine: 'EngineType' = 'auto', plan_stage: 'PlanStage' = 'ir', _check_order: 'bool' = True, optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'str | None' |
typed-parity | — |
sink_avro |
def sink_avro( |
polars.LazyFrame |
— | divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_csv |
def sink_csv( |
polars.LazyFrame |
(self, path: 'str | Path | IO[bytes] | IO[str] | PartitionBy', *, include_bom: 'bool' = False, compression: "Literal['uncompressed', 'gzip', 'zstd']" = 'uncompressed', compression_level: 'int | None' = None, check_extension: 'bool' = True, include_header: 'bool' = True, separator: 'str' = ',', line_terminator: 'str' = '\n', quote_char: 'str' = '"', batch_size: 'int' = 1024, datetime_format: 'str | None' = None, date_format: 'str | None' = None, time_format: 'str | None' = None, float_scientific: 'bool | None' = None, float_precision: 'int | None' = None, decimal_comma: 'bool' = False, null_value: 'str | None' = None, quote_style: 'CsvQuoteStyle | None' = None, maintain_order: 'bool' = True, storage_options: 'StorageOptionsDict | None' = None, credential_provider: "CredentialProviderFunction | Literal['auto'] | None" = 'auto', retries: 'int | None' = None, sync_on_close: 'SyncOnCloseMethod | None' = None, mkdir: 'bool' = False, lazy: 'bool' = False, engine: 'EngineType' = 'auto', optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'LazyFrame | None' |
divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_database |
def sink_database( |
polars.LazyFrame |
— | divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_delta |
def sink_delta( |
polars.LazyFrame |
(self, target: 'str | Path | deltalake.DeltaTable', *, mode: "Literal['error', 'append', 'overwrite', 'ignore', 'merge']" = 'error', storage_options: 'StorageOptionsDict | None' = None, credential_provider: "CredentialProviderFunction | Literal['auto'] | None" = 'auto', delta_write_options: 'dict[str, Any] | None' = None, delta_merge_options: 'dict[str, Any] | None' = None, optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'deltalake.table.TableMerger | None' |
divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_excel |
def sink_excel(self, path: str, *, worksheet: str = ...) -> None |
polars.LazyFrame |
— | divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_ipc |
def sink_ipc( |
polars.LazyFrame |
(self, path: 'str | Path | IO[bytes] | PartitionBy', *, compression: 'IpcCompression | None' = 'uncompressed', compat_level: 'CompatLevel | None' = None, record_batch_size: 'int | None' = None, maintain_order: 'bool' = True, storage_options: 'StorageOptionsDict | None' = None, credential_provider: "CredentialProviderFunction | Literal['auto'] | None" = 'auto', retries: 'int | None' = None, sync_on_close: 'SyncOnCloseMethod | None' = None, mkdir: 'bool' = False, lazy: 'bool' = False, engine: 'EngineType' = 'auto', optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>, _record_batch_statistics: 'bool' = False) -> 'LazyFrame | None' |
divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_ndjson |
def sink_ndjson(self, path: str, *, storage_options: StorageOptions | None = ...) -> None |
polars.LazyFrame |
(self, path: 'str | Path | IO[bytes] | IO[str] | PartitionBy', *, compression: "Literal['uncompressed', 'gzip', 'zstd']" = 'uncompressed', compression_level: 'int | None' = None, check_extension: 'bool' = True, maintain_order: 'bool' = True, storage_options: 'StorageOptionsDict | None' = None, credential_provider: "CredentialProviderFunction | Literal['auto'] | None" = 'auto', retries: 'int | None' = None, sync_on_close: 'SyncOnCloseMethod | None' = None, mkdir: 'bool' = False, lazy: 'bool' = False, engine: 'EngineType' = 'auto', optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'LazyFrame | None' |
divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
sink_parquet |
def sink_parquet( |
polars.LazyFrame |
(self, path: 'str | Path | IO[bytes] | PartitionBy', *, compression: 'str' = 'zstd', compression_level: 'int | None' = None, statistics: 'bool | str | dict[str, bool]' = True, row_group_size: 'int | None' = None, data_page_size: 'int | None' = None, maintain_order: 'bool' = True, storage_options: 'StorageOptionsDict | None' = None, credential_provider: "CredentialProviderFunction | Literal['auto'] | None" = 'auto', retries: 'int | None' = None, sync_on_close: 'SyncOnCloseMethod | None' = None, metadata: 'ParquetMetadata | None' = None, arrow_schema: 'ArrowSchemaExportable | None' = None, mkdir: 'bool' = False, lazy: 'bool' = False, engine: 'EngineType' = 'auto', optimizations: 'QueryOptFlags' = <polars.lazyframe.opt_flags.QueryOptFlags object at 0x107f44670>) -> 'LazyFrame | None' |
divergence | PlanFrame uses sink_* naming for lazy IO boundaries |
slice |
def slice(self, offset: int, length: int | None = ...) -> Self |
polars.LazyFrame |
(self, offset: 'int', length: 'int | None' = None) -> 'LazyFrame' |
typed-parity | — |
sort |
def sort( |
polars.LazyFrame |
(self, by: 'IntoExpr | Iterable[IntoExpr]', *more_by: 'IntoExpr', descending: 'bool | Sequence[bool]' = False, nulls_last: 'bool | Sequence[bool]' = False, maintain_order: 'bool' = False, multithreaded: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
source |
def source( |
polars.LazyFrame |
— | typed-parity | — |
sql |
def sql(self, query: str, *, table_name: str = ...) -> NoReturn |
polars.LazyFrame |
(self, query: 'str', *, table_name: 'str' = 'self') -> 'LazyFrame' |
typed-parity | — |
tail |
def tail(self, n: int) -> Self |
polars.LazyFrame |
(self, n: 'int' = 5) -> 'LazyFrame' |
typed-parity | — |
to_dict |
def to_dict(self, *, options: ExecutionOptions | None = ...) -> dict[str, list[object]] |
polars.LazyFrame |
— | typed-parity | — |
to_dicts |
def to_dicts(self, *, options: ExecutionOptions | None = ...) -> list[dict[str, object]] |
polars.LazyFrame |
— | typed-parity | — |
union_distinct |
def union_distinct(self, other: Frame[SchemaT, BackendFrameT, BackendExprT]) -> Self |
polars.LazyFrame |
— | typed-parity | — |
unique |
def unique( |
polars.LazyFrame |
(self, subset: 'IntoExpr | Collection[IntoExpr] | None' = None, *, keep: 'UniqueKeepStrategy' = 'any', maintain_order: 'bool' = False) -> 'LazyFrame' |
typed-parity | — |
unnest |
def unnest(self, __c1: LiteralString, *columns: LiteralString) -> Self |
polars.LazyFrame |
(self, columns: 'ColumnNameOrSelector | Collection[ColumnNameOrSelector]', *more_columns: 'ColumnNameOrSelector', separator: 'str | None' = None) -> 'LazyFrame' |
typed-parity | — |
unpivot |
def unpivot( |
polars.LazyFrame |
(self, on: 'ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None' = None, *, index: 'ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None' = None, variable_name: 'str | None' = None, value_name: 'str | None' = None, streamable: 'bool' = True) -> 'LazyFrame' |
typed-parity | — |
vstack |
def vstack(self, other: Frame[SchemaT, BackendFrameT, BackendExprT]) -> Self |
polars.LazyFrame |
— | typed-parity | — |
with_columns |
def with_columns( |
polars.LazyFrame |
(self, *exprs: 'IntoExpr | Iterable[IntoExpr]', **named_exprs: 'IntoExpr') -> 'LazyFrame' |
typed-parity | — |
with_row_index |
def with_row_index(self, *, name: str = ..., offset: int = ...) -> Self |
polars.LazyFrame |
(self, name: 'str' = 'index', offset: 'int' = 0) -> 'LazyFrame' |
typed-parity | — |
write_avro |
def write_avro( |
polars.LazyFrame |
— | typed-parity | — |
write_csv |
def write_csv( |
polars.LazyFrame |
— | typed-parity | — |
write_database |
def write_database( |
polars.LazyFrame |
— | typed-parity | — |
write_delta |
def write_delta( |
polars.LazyFrame |
— | typed-parity | — |
write_excel |
def write_excel(self, path: str, *, worksheet: str = ...) -> None |
polars.LazyFrame |
— | typed-parity | — |
write_ipc |
def write_ipc( |
polars.LazyFrame |
— | typed-parity | — |
write_ndjson |
def write_ndjson(self, path: str, *, storage_options: StorageOptions | None = ...) -> None |
polars.LazyFrame |
— | typed-parity | — |
write_parquet |
def write_parquet( |
polars.LazyFrame |
— | typed-parity | — |