API_COVERAGE.md

belugas vs Polars API Comparison Report

This report shows the API coverage of belugas compared to polars.

Summary

Each summary cell is relative to Polars.

Class	Coverage	Belugas Total	Compared	Matched	Missing	Mismatched	Belugas Only
LazyFrame	███░░░░░░░ (32.9%)	63	55	27	27	28	8
Expr	███░░░░░░░ (39.1%)	330	129	84	86	45	201
LazyGroupBy	██████░░░░ (62.5%)	12	12	10	4	2	0
ExprStringNameSpace	███░░░░░░░ (31.2%)	122	38	15	10	23	84
ExprListNameSpace	████░░░░░░ (41.9%)	90	28	18	15	10	62
ExprStructNameSpace	████░░░░░░ (40.0%)	16	3	2	2	1	13
ExprNameNameSpace	██████░░░░ (60.0%)	8	7	6	3	1	1
ExprArrayNameSpace	████░░░░░░ (45.2%)	70	26	14	5	12	44
ExprDateTimeNameSpace	████░░░░░░ (46.7%)	79	27	21	18	6	52
ModuleFunctions	█░░░░░░░░░ (16.6%)	80	65	28	104	37	15
selectors	█████░░░░░ (54.3%)	23	23	19	12	4	0
DataType	█████░░░░░ (53.3%)	14	10	8	5	2	4
Schema	░░░░░░░░░░ (0.0%)	0	0	0	19	0	0

LazyFrame

[x] Missing Methods (27)

• collect_async
  • Polars: (gevent: bool, engine: EngineType, optimizations: QueryOptFlags) -> Awaitable[DataFrame] | _GeventDataFrameResult[DataFrame]
• collect_batches
  • Polars: (chunk_size: int | None, maintain_order: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags) -> Iterator[DataFrame]
• deserialize
  • Polars: (source: str | bytes | Path | IOBase, format: SerializationFormat) -> LazyFrame
• execute
  • Polars: (optimizations: QueryOptFlags, engine: EngineType, **_kwargs: Any) -> QueryResult
• gather
  • Polars: (indices: int | Sequence[int] | IntoExpr | pl.Series | np.ndarray[Any, Any] | pl.LazyFrame, null_on_oob: bool) -> LazyFrame
• group_by_dynamic
  • Polars: (index_column: IntoExpr, every: str | timedelta, period: str | timedelta | None, offset: str | timedelta | None, include_boundaries: bool, closed: ClosedInterval, label: Label, group_by: IntoExpr | Iterable[IntoExpr] | None, start_by: StartBy) -> LazyGroupBy
• inspect
  • Polars: (fmt: str) -> LazyFrame
• interpolate
  • Polars: () -> LazyFrame
• join_where
  • Polars: (other: LazyFrame, *predicates: Expr | Iterable[Expr], suffix: str) -> LazyFrame
• map_batches
  • Polars: (function: Callable[[DataFrame], DataFrame], predicate_pushdown: bool, projection_pushdown: bool, slice_pushdown: bool, no_optimizations: bool | None, schema: None | SchemaDict, validate_output_schema: bool, streamable: bool) -> LazyFrame
• match_to_schema
  • Polars: (schema: SchemaDict | Schema, missing_columns: Literal['insert', 'raise'] | Mapping[str, Literal['insert', 'raise'] | Expr] | Expr, missing_struct_fields: Literal['insert', 'raise'] | Mapping[str, Literal['insert', 'raise']], extra_columns: Literal['ignore', 'raise'], extra_struct_fields: Literal['ignore', 'raise'] | Mapping[str, Literal['ignore', 'raise']], integer_cast: Literal['upcast', 'forbid'] | Mapping[str, Literal['upcast', 'forbid']], float_cast: Literal['upcast', 'forbid'] | Mapping[str, Literal['upcast', 'forbid']]) -> LazyFrame
• merge_sorted
  • Polars: (other: LazyFrame, key: str, maintain_order: bool) -> LazyFrame
• pipe_with_schema
  • Polars: (function: Callable[[LazyFrame, Schema], LazyFrame]) -> LazyFrame
• profile
  • Polars: (type_coercion: bool, predicate_pushdown: bool, projection_pushdown: bool, simplify_expression: bool, no_optimization: bool, slice_pushdown: bool, comm_subplan_elim: bool, comm_subexpr_elim: bool, cluster_with_columns: bool, collapse_joins: bool, show_plot: bool, truncate_nodes: int, figsize: tuple[int, int], engine: EngineType, optimizations: QueryOptFlags, **_kwargs: Any) -> tuple[DataFrame, DataFrame]
• remote
  • Polars: (context: ClientContext | None, plan_type: PlanTypePreference, n_retries: int, engine: Engine, scaling_mode: ScalingMode) -> LazyFrameRemote
• remove
  • Polars: (*predicates: IntoExprColumn | Iterable[IntoExprColumn] | bool | list[bool] | np.ndarray[Any, Any], **constraints: Any) -> LazyFrame
• rolling
  • Polars: (index_column: IntoExpr, period: str | timedelta, offset: str | timedelta | None, closed: ClosedInterval, group_by: IntoExpr | Iterable[IntoExpr] | None) -> LazyGroupBy
• serialize
  • Polars: (file: IOBase | str | Path | None, format: SerializationFormat) -> bytes | str | None
• set_sorted
  • Polars: (column: str | list[str], *more_columns: str, descending: bool | list[bool], nulls_last: bool | list[bool]) -> LazyFrame
• show_graph
  • Polars: (optimized: bool, show: bool, output_path: str | Path | None, raw_output: bool, figsize: tuple[float, float], 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, collapse_joins: bool, engine: EngineType, plan_stage: PlanStage,_check_order: bool, optimizations: QueryOptFlags) -> str | None
• sink_batches
  • Polars: (function: Callable[[DataFrame], bool | None], chunk_size: int | None, maintain_order: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags) -> LazyFrame | None
• sink_delta
  • Polars: (target: DeltaTable, mode: Literal['error', 'append', 'overwrite', 'ignore', 'merge'], storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, delta_write_options: dict[str, Any] | None, delta_merge_options: dict[str, Any] | None, optimizations: QueryOptFlags) -> TableMerger | None
• sink_iceberg
  • Polars: (target: Table, mode: Literal['append', 'overwrite'], catalog: IcebergCatalogConfig | None, storage_options: StorageOptionsDict | None) -> DataFrame
• sink_ipc
  • Polars: (path: str | Path | IO[bytes] | PartitionBy, compression: IpcCompression | None, compat_level: CompatLevel | None, record_batch_size: int | None, maintain_order: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, sync_on_close: SyncOnCloseMethod | None, mkdir: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags, _record_batch_statistics: bool) -> LazyFrame | None
• sink_ndjson
  • Polars: (path: str | Path | IO[bytes] | IO[str] | PartitionBy, compression: Literal['uncompressed', 'gzip', 'zstd'], compression_level: int | None, check_extension: bool, maintain_order: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, sync_on_close: SyncOnCloseMethod | None, mkdir: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags) -> LazyFrame | None
• sql
  • Polars: (query: str, table_name: str) -> LazyFrame
• update
  • Polars: (other: LazyFrame, on: str | Sequence[str] | None, how: Literal['left', 'inner', 'full'], left_on: str | Sequence[str] | None, right_on: str | Sequence[str] | None, include_nulls: bool, maintain_order: MaintainOrderJoin | None) -> LazyFrame

[!] Signature Mismatches (28)

• bottom_k
  • Polars: (k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]) -> LazyFrame
  • belugas: (k: int, by: TryIter[IntoExpr], reverse: DescConds) -> Self
• cast
  • Polars: (dtypes: Mapping[ColumnNameOrSelector | PolarsDataType, PolarsDataType | PythonDataType] | PolarsDataType | pl.DataTypeExpr | Schema, strict: bool) -> LazyFrame
  • belugas: (dtypes: Mapping[str, dt.DataType] | dt.DataType) -> Self
• collect
  • Polars: (type_coercion: 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, collapse_joins: bool, no_optimization: bool, engine: EngineType, background: bool, optimizations: QueryOptFlags, **_kwargs: Any) -> DataFrame | InProcessQuery
  • belugas: () -> DataFrame
• describe
  • Polars: (percentiles: Sequence[float] | float | None, interpolation: QuantileMethod) -> DataFrame
  • belugas: () -> Self
• drop
  • Polars: (*columns: ColumnNameOrSelector | Iterable[ColumnNameOrSelector], strict: bool) -> LazyFrame
  • belugas: (columns: TryIter[IntoExprColumn], *more_columns: IntoExprColumn) -> Self
• drop_nans
  • Polars: (subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None) -> LazyFrame
  • belugas: (subset: TryIter[str]) -> Self
• drop_nulls
  • Polars: (subset: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None) -> LazyFrame
  • belugas: (subset: TryIter[str]) -> Self
• explain
  • Polars: (format: ExplainFormat, optimized: bool, type_coercion: 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, collapse_joins: bool, streaming: bool, engine: EngineType, tree_format: bool | None, optimizations: QueryOptFlags) -> str
  • belugas: (kind: ExplainType | ExplainTypeLiteral) -> str
• explode
  • Polars: (columns: ColumnNameOrSelector | Iterable[ColumnNameOrSelector], *more_columns: ColumnNameOrSelector, empty_as_null: bool, keep_nulls: bool) -> LazyFrame
  • belugas: (columns: TryIter[IntoExprColumn], *more_columns: IntoExprColumn) -> Self
• fill_null
  • Polars: (value: Any | Expr | None, strategy: FillNullStrategy | None, limit: int | None, matches_supertype: bool) -> LazyFrame
  • belugas: (value: IntoExpr, strategy: FillNullStrategy | None, limit: int | None) -> Self
• filter
  • Polars: (*predicates: IntoExprColumn | Iterable[IntoExprColumn] | bool | list[bool] | np.ndarray[Any, Any], **constraints: Any) -> LazyFrame
  • belugas: (predicates: TryIter[IntoExprColumn], *more_predicates: IntoExprColumn, **constraints: IntoExpr) -> Self
• group_by
  • Polars: (*by: IntoExpr | Iterable[IntoExpr], maintain_order: bool, **named_by: IntoExpr) -> LazyGroupBy
  • belugas: (keys: TryIter[IntoExpr], *more_keys: IntoExpr, drop_null_keys: bool, strategy: GroupByClause | None) -> LazyGroupBy
• join
  • Polars: (other: LazyFrame, on: str | Expr | Sequence[str | Expr] | None, how: JoinStrategy, left_on: str | Expr | Sequence[str | Expr] | None, right_on: str | Expr | Sequence[str | Expr] | None, suffix: str, validate: JoinValidation, nulls_equal: bool, coalesce: bool | None, maintain_order: MaintainOrderJoin | None, allow_parallel: bool, force_parallel: bool) -> LazyFrame
  • belugas: (other: Self, on: TryIter[str], how: JoinStrategy, left_on: TryIter[str], right_on: TryIter[str], suffix: str) -> Self
• join_asof
  • Polars: (other: LazyFrame, left_on: str | None | Expr, right_on: str | None | Expr, on: str | None | Expr, by_left: str | Sequence[str] | None, by_right: str | Sequence[str] | None, by: str | Sequence[str] | None, strategy: AsofJoinStrategy, suffix: str, tolerance: str | int | float | timedelta | None, allow_parallel: bool, force_parallel: bool, coalesce: bool, allow_exact_matches: bool, check_sortedness: bool) -> LazyFrame
  • belugas: (other: Self, left_on: str | None, right_on: str | None, on: str | None, by_left: TryIter[str], by_right: TryIter[str], by: TryIter[str], strategy: AsofJoinStrategy, suffix: str) -> Self
• pipe
  • Polars: (function: Callable[Concatenate[LazyFrame, P], T], *args: args, **kwargs: kwargs) -> T
  • belugas: (func, *args, **kwargs)
• pivot
  • Polars: (on: ColumnNameOrSelector | Sequence[ColumnNameOrSelector], on_columns: Sequence[Any] | pl.Series | pl.DataFrame, index: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None, values: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None, aggregate_function: PivotAgg | Expr | None, maintain_order: bool, separator: str, column_naming: Literal['auto', 'combine']) -> LazyFrame
  • belugas: (on: TryIter[str], on_columns: TryIter[PythonLiteral], index: TryIter[str], values: TryIter[str], aggregate_function: PivotAgg, maintain_order: bool, separator: str) -> Self
• quantile
  • Polars: (quantile: float | Expr, interpolation: QuantileMethod) -> LazyFrame
  • belugas: (quantile: float) -> Self
• rename
  • Polars: (mapping: Mapping[str, str] | Callable[[str], str], strict: bool) -> LazyFrame
  • belugas: (mapping: Mapping[str, str]) -> Self
• shift
  • Polars: (n: int | IntoExprColumn, fill_value: IntoExpr | None) -> LazyFrame
  • belugas: (n: int, fill_value: IntoExpr) -> Self
• show
  • Polars: (limit: int | None, ascii_tables: bool | None, decimal_separator: str | None, thousands_separator: str | bool | None, float_precision: int | None, fmt_float: FloatFmt | None, fmt_str_lengths: int | None, fmt_table_cell_list_len: int | None, tbl_cell_alignment: Alignment | None, tbl_cell_numeric_alignment: Alignment | None, tbl_cols: int | None, tbl_column_data_type_inline: bool | None, tbl_dataframe_shape_below: bool | None, tbl_formatting: TableFormatNames | None, tbl_hide_column_data_types: bool | None, tbl_hide_column_names: bool | None, tbl_hide_dtype_separator: bool | None, tbl_hide_dataframe_shape: bool | None, tbl_width_chars: int | None, trim_decimal_zeros: bool | None) -> None
  • belugas: (max_width: SupportsInt | None, max_rows: SupportsInt | None, max_col_width: SupportsInt | None, null_value: str | None, render_mode: RenderModeLiteral | None) -> None
• sink_csv
  • Polars: (path: str | Path | IO[bytes] | IO[str] | PartitionBy, include_bom: bool, compression: Literal['uncompressed', 'gzip', 'zstd'], compression_level: int | None, check_extension: bool, include_header: bool, separator: str, line_terminator: str, quote_char: str, 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: CsvQuoteStyle | None, maintain_order: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, sync_on_close: SyncOnCloseMethod | None, mkdir: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags) -> LazyFrame | None
  • belugas: (path: str | Path, separator: str, include_header: bool, na_rep: str | None, quotechar: str | None, escapechar: str | None, date_format: str | None, timestamp_format: str | None, quoting: str | int | None, encoding: str | None, compression: CsvCompression | None, overwrite: bool | None, per_thread_output: bool | None, use_tmp_file: bool | None, partition_by: list[str] | None, write_partition_columns: bool | None) -> None
• sink_parquet
  • Polars: (path: str | Path | IO[bytes] | PartitionBy, compression: str, compression_level: int | None, statistics: bool | str | dict[str, bool], row_group_size: int | None, data_page_size: int | None, maintain_order: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, sync_on_close: SyncOnCloseMethod | None, metadata: ParquetMetadata | None, arrow_schema: ArrowSchemaExportable | None, mkdir: bool, lazy: bool, engine: EngineType, optimizations: QueryOptFlags, _sinked_paths_callback: SinkedPathsCallback | None) -> LazyFrame | None
  • belugas: (path: str | Path, compression: ParquetCompression | None, field_ids: ParquetFieldsOptions | None, row_group_size_bytes: str | int | None, row_group_size: int | None, overwrite: bool | None, per_thread_output: bool | None, use_tmp_file: bool | None, partition_by: list[str] | None, write_partition_columns: bool | None, append: bool | None, filename_pattern: str | None, file_size_bytes: str | int | None) -> None
• sort
  • Polars: (by: IntoExpr | Iterable[IntoExpr], *more_by: IntoExpr, descending: bool | Sequence[bool], nulls_last: bool | Sequence[bool], maintain_order: bool, multithreaded: bool) -> LazyFrame
  • belugas: (by: TryIter[IntoExpr], *more_by: IntoExpr, descending: DescConds, nulls_last: TrySeq[bool]) -> Self
• top_k
  • Polars: (k: int, by: IntoExpr | Iterable[IntoExpr], reverse: bool | Sequence[bool]) -> LazyFrame
  • belugas: (k: int, by: TryIter[IntoExpr], reverse: DescConds) -> Self
• unique
  • Polars: (subset: IntoExpr | Collection[IntoExpr] | None, keep: UniqueKeepStrategy, maintain_order: bool) -> LazyFrame
  • belugas: (subset: TryIter[str] | None, keep: UniqueKeepStrategy, order_by: TrySeq[str]) -> Self
• unnest
  • Polars: (columns: ColumnNameOrSelector | Collection[ColumnNameOrSelector] | None, *more_columns: ColumnNameOrSelector, separator: str | None) -> LazyFrame
  • belugas: (columns: TryIter[IntoExprColumn], *more_columns: IntoExprColumn) -> Self
• unpivot
  • Polars: (on: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None, index: ColumnNameOrSelector | Sequence[ColumnNameOrSelector] | None, variable_name: str | None, value_name: str | None, streamable: bool) -> LazyFrame
  • belugas: (on: TryIter[str], index: TryIter[str], variable_name: str, value_name: str, order_by: TryIter[str]) -> Self
• with_row_index
  • Polars: (name: str, offset: int) -> LazyFrame
  • belugas: (name: str, order_by: TryIter[str]) -> Self

[+] Extra Methods (belugas-only) (8)

• fetch_all
• group_by_all
• height
• inner
• join_cross
• query
• shape
• union

Expr

[x] Missing Methods (86)

• agg_groups
  • Polars: () -> Expr
• append
  • Polars: (other: IntoExpr, upcast: bool) -> Expr
• arg_true
  • Polars: () -> Expr
• arg_unique
  • Polars: () -> Expr
• bitwise_count_ones
  • Polars: () -> Expr
• bitwise_count_zeros
  • Polars: () -> Expr
• bitwise_leading_ones
  • Polars: () -> Expr
• bitwise_leading_zeros
  • Polars: () -> Expr
• bitwise_trailing_ones
  • Polars: () -> Expr
• bitwise_trailing_zeros
  • Polars: () -> Expr
• bottom_k
  • Polars: (k: int | IntoExprColumn) -> Expr
• bottom_k_by
  • Polars: (by: IntoExpr | Iterable[IntoExpr], k: int | IntoExprColumn, reverse: bool | Sequence[bool]) -> Expr
• cat
  • Polars: () -> ExprCatNameSpace
• cumulative_eval
  • Polars: (expr: Expr, min_samples: int) -> Expr
• cut
  • Polars: (breaks: Sequence[float], labels: Sequence[str_] | None, left_closed: bool, include_breaks: bool) -> Expr
• deserialize
  • Polars: (source: str_ | Path | IOBase | bytes, format: SerializationFormat) -> Expr
• drop_nans
  • Polars: () -> Expr
• drop_nulls
  • Polars: () -> Expr
• eq_missing
  • Polars: (other: Any) -> Expr
• ewm_mean
  • Polars: (com: float | None, span: float | None, half_life: float | None, alpha: float | None, adjust: bool, min_samples: int, ignore_nulls: bool) -> Expr
• ewm_mean_by
  • Polars: (by: str_| IntoExpr, half_life: str_ | timedelta) -> Expr
• ewm_std
  • Polars: (com: float | None, span: float | None, half_life: float | None, alpha: float | None, adjust: bool, bias: bool, min_samples: int, ignore_nulls: bool) -> Expr
• ewm_var
  • Polars: (com: float | None, span: float | None, half_life: float | None, alpha: float | None, adjust: bool, bias: bool, min_samples: int, ignore_nulls: bool) -> Expr
• exclude
  • Polars: (columns: str_| PolarsDataType | Collection[str_ | PolarsDataType], *more_columns: str_ | PolarsDataType) -> Expr
• explode
  • Polars: (empty_as_null: bool, keep_nulls: bool) -> Expr
• ext
  • Polars: () -> ExprExtensionNameSpace
• extend_constant
  • Polars: (value: IntoExpr, n: int | IntoExprColumn) -> Expr
• gather
  • Polars: (indices: int | Sequence[int] | IntoExpr | Series | np.ndarray[Any, Any], null_on_oob: bool) -> Expr
• gather_every
  • Polars: (n: int, offset: int) -> Expr
• get
  • Polars: (index: int | Expr, null_on_oob: bool) -> Expr
• head
  • Polars: (n: int | Expr) -> Expr
• hist
  • Polars: (bins: IntoExpr | None, bin_count: int | None, include_category: bool, include_breakpoint: bool) -> Expr
• index_of
  • Polars: (element: IntoExpr) -> Expr
• inspect
  • Polars: (fmt: str_) -> Expr
• interpolate
  • Polars: (method: InterpolationMethod) -> Expr
• interpolate_by
  • Polars: (by: IntoExpr) -> Expr
• is_empty
  • Polars: (ignore_nulls: bool) -> Expr
• item
  • Polars: (allow_empty: bool) -> Expr
• limit
  • Polars: (n: int | Expr) -> Expr
• lower_bound
  • Polars: () -> Expr
• map_batches
  • Polars: (function: Callable[[Series], Series | Any], return_dtype: DataTypeExpr | None, agg_list: bool, is_elementwise: bool, returns_scalar: bool) -> Expr
• map_elements
  • Polars: (function: Callable[[Any], Any], return_dtype: DataTypeExpr | None, skip_nulls: bool, pass_name: bool, strategy: MapElementsStrategy, returns_scalar: bool) -> Expr
• meta
  • Polars: () -> ExprMetaNameSpace
• nan_max
  • Polars: () -> Expr
• nan_min
  • Polars: () -> Expr
• ne_missing
  • Polars: (other: Any) -> Expr
• peak_max
  • Polars: () -> Expr
• peak_min
  • Polars: () -> Expr
• qcut
  • Polars: (quantiles: Sequence[float] | int, labels: Sequence[str_] | None, left_closed: bool, allow_duplicates: bool, include_breaks: bool) -> Expr
• rechunk
  • Polars: () -> Expr
• reinterpret
  • Polars: (signed: bool | None, dtype: PolarsDataType | None) -> Expr
• replace_strict
  • Polars: (old: IntoExpr | Sequence[Any] | Mapping[Any, Any], new: IntoExpr | Sequence[Any] | NoDefault, default: IntoExpr | NoDefault, return_dtype: DataTypeExpr | None) -> Expr
• reshape
  • Polars: (dimensions: tuple[int, ...]) -> Expr
• reverse
  • Polars: () -> Expr
• rle
  • Polars: () -> Expr
• rle_id
  • Polars: () -> Expr
• rolling
  • Polars: (index_column: IntoExprColumn, period: str_ | timedelta, offset: str_ | timedelta | None, closed: ClosedInterval) -> Expr
• rolling_kurtosis
  • Polars: (window_size: int, fisher: bool, bias: bool, min_samples: int | None, center: bool) -> Expr
• rolling_map
  • Polars: (function: Callable[[Series], Any], window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
• rolling_max_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_mean_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_median_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_min_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_quantile
  • Polars: (quantile: float, interpolation: QuantileMethod, window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
• rolling_quantile_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, quantile: float, interpolation: QuantileMethod, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_rank
  • Polars: (window_size: int, method: RankMethod, seed: int | None, min_samples: int | None, center: bool) -> Expr
• rolling_rank_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, method: RankMethod, seed: int | None, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_skew
  • Polars: (window_size: int, bias: bool, min_samples: int | None, center: bool) -> Expr
• rolling_std_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval, ddof: int) -> Expr
• rolling_sum_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval) -> Expr
• rolling_var_by
  • Polars: (by: IntoExpr, window_size: timedelta | str_, min_samples: int, closed: ClosedInterval, ddof: int) -> Expr
• round_sig_figs
  • Polars: (digits: int) -> Expr
• sample
  • Polars: (n: int | IntoExprColumn | None, fraction: float | IntoExprColumn | None, with_replacement: bool, shuffle: bool, seed: int | None) -> Expr
• search_sorted
  • Polars: (element: ndarray[Any, Any], side: SearchSortedSide, descending: bool) -> Expr
• set_sorted
  • Polars: (descending: bool, nulls_last: bool) -> Expr
• shuffle
  • Polars: (seed: int | None) -> Expr
• slice
  • Polars: (offset: int | Expr, length: int | Expr | None) -> Expr
• sort
  • Polars: (descending: bool, nulls_last: bool) -> Expr
• sort_by
  • Polars: (by: IntoExpr | Iterable[IntoExpr], *more_by: IntoExpr, descending: bool | Sequence[bool], nulls_last: bool | Sequence[bool], multithreaded: bool, maintain_order: bool) -> Expr
• tail
  • Polars: (n: int | Expr) -> Expr
• to_physical
  • Polars: () -> Expr
• top_k
  • Polars: (k: int | IntoExprColumn) -> Expr
• top_k_by
  • Polars: (by: IntoExpr | Iterable[IntoExpr], k: int | IntoExprColumn, reverse: bool | Sequence[bool]) -> Expr
• unique_counts
  • Polars: () -> Expr
• upper_bound
  • Polars: () -> Expr
• value_counts
  • Polars: (sort: bool, parallel: bool, name: str_ | None, normalize: bool) -> Expr

[!] Signature Mismatches (45)

• alias
  • Polars: (name: str_) -> Expr
  • belugas: (name: str) -> Self
• all
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Self
• and_
  • Polars: (*others: Any) -> Expr
  • belugas: (other: IntoExpr) -> Self
• any
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Self
• arg_max
  • Polars: () -> Expr
  • belugas: (val: IntoExpr, col2: IntoExprColumn | int | None) -> Self
• arg_min
  • Polars: () -> Expr
  • belugas: (val: IntoExpr, col2: IntoExprColumn | int | None) -> Self
• cast
  • Polars: (dtype: DataTypeExpr | type[Any], strict: bool, wrap_numerical: bool) -> Expr
  • belugas: (dtype: IntoDataType) -> Self
• clip
  • Polars: (lower_bound: NumericLiteral | TemporalLiteral | IntoExprColumn | None, upper_bound: NumericLiteral | TemporalLiteral | IntoExprColumn | None) -> Expr
  • belugas: (lower_bound: IntoExpr, upper_bound: IntoExpr) -> Self
• diff
  • Polars: (n: int | IntoExpr, null_behavior: NullBehavior) -> Expr
  • belugas: () -> Self
• dot
  • Polars: (other: Expr | str_) -> Expr
  • belugas: (other: IntoExpr) -> Self
• fill_nan
  • Polars: (value: int | float | Expr | None) -> Expr
  • belugas: (value: float | IntoExprColumn | None) -> Self
• fill_null
  • Polars: (value: Any | Expr | None, strategy: FillNullStrategy | None, limit: int | None) -> Expr
  • belugas: (value: IntoExpr, strategy: FillNullStrategy | None, limit: int | None) -> Self
• first
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Self
• forward_fill
  • Polars: (limit: int | None) -> Expr
  • belugas: () -> Self
• from_json
  • Polars: (value: str_) -> Expr
  • belugas: (col1: IntoExprColumn) -> Self
• hash
  • Polars: (seed: int, seed_1: int | None, seed_2: int | None, seed_3: int | None) -> Expr
  • belugas: (seed: int) -> Self
• implode
  • Polars: (maintain_order: bool) -> Expr
  • belugas: () -> Self
• is_in
  • Polars: (other: Expr | Collection[Any] | Series, nulls_equal: bool) -> Expr
  • belugas: (args: TryIter[IntoExpr], *more_args: IntoExpr) -> Self
• last
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Self
• log
  • Polars: (base: float | IntoExpr) -> Expr
  • belugas: (x: IntoExprColumn | float | None) -> Self
• max
  • Polars: () -> Expr
  • belugas: (col1: IntoExprColumn | int | None) -> Self
• max_by
  • Polars: (by: IntoExpr) -> Expr
  • belugas: (by: IntoExpr, col2: IntoExprColumn | int | None) -> Self
• min
  • Polars: () -> Expr
  • belugas: (col1: IntoExprColumn | int | None) -> Self
• min_by
  • Polars: (by: IntoExpr) -> Expr
  • belugas: (by: IntoExpr, col2: IntoExprColumn | int | None) -> Self
• mod
  • Polars: (other: Any) -> Expr
  • belugas: (col1: IntoExprColumn | Decimal | float) -> Self
• mode
  • Polars: (maintain_order: bool) -> Expr
  • belugas: () -> Self
• or_
  • Polars: (*others: Any) -> Expr
  • belugas: (other: IntoExpr) -> Self
• over
  • Polars: (partition_by: IntoExpr | Iterable[IntoExpr] | None, *more_exprs: IntoExpr, order_by: IntoExpr | Iterable[IntoExpr] | None, descending: bool, nulls_last: bool, mapping_strategy: WindowMappingStrategy) -> Expr
  • belugas: (partition_by: TryIter[IntoExpr], *more_exprs: IntoExpr, order_by: TryIter[IntoExpr], descending: bool, nulls_last: bool) -> Self
• pct_change
  • Polars: (n: int | IntoExprColumn) -> Expr
  • belugas: (n: int) -> Self
• pipe
  • Polars: (function: Callable[Concatenate[Expr, P], T], *args: args, **kwargs: kwargs) -> T
  • belugas: (func, *args, **kwargs)
• pow
  • Polars: (exponent: IntoExprColumn | int | float) -> Expr
  • belugas: (y: IntoExprColumn | float) -> Self
• quantile
  • Polars: (quantile: float | list_[float] | Expr, interpolation: QuantileMethod) -> Expr
  • belugas: (quantile: float, interpolation: bool) -> Self
• rank
  • Polars: (method: RankMethod, descending: bool, seed: int | None) -> Expr
  • belugas: (method: RankMethod, descending: bool) -> Self
• repeat_by
  • Polars: (by: Series | Expr | str_ | int) -> Expr
  • belugas: (by: IntoExprColumn | int) -> Self
• replace
  • Polars: (old: IntoExpr | Sequence[Any] | Mapping[Any, Any], new: IntoExpr | Sequence[Any] | NoDefault, default: IntoExpr | NoDefault, return_dtype: PolarsDataType | None) -> Expr
  • belugas: (old: IntoExpr, new: IntoExpr) -> Self
• rolling_max
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool) -> Self
• rolling_mean
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool) -> Self
• rolling_median
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool) -> Self
• rolling_min
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool) -> Self
• rolling_std
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool, ddof: int) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool, ddof: int) -> Self
• rolling_sum
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool) -> Self
• rolling_var
  • Polars: (window_size: int, weights: list_[float] | None, min_samples: int | None, center: bool, ddof: int) -> Expr
  • belugas: (window_size: int, min_samples: int | None, center: bool, ddof: int) -> Self
• shift
  • Polars: (n: int | IntoExprColumn, fill_value: IntoExpr | None) -> Expr
  • belugas: (n: int) -> Self
• unique
  • Polars: (maintain_order: bool) -> Expr
  • belugas: () -> Self
• xor
  • Polars: (other: Any) -> Expr
  • belugas: (right: IntoExprColumn | bytes | bytearray | memoryview | int) -> Self

[+] Extra Methods (belugas-only) (201)

• acos
• acosh
• age
• ago
• any_value
• approx_count_distinct
• approx_quantile
• approx_top_k
• arbitrary
• arg_max_null
• arg_max_nulls_last
• arg_min_null
• arg_min_nulls_last
• argmax
• argmin
• asin
• asinh
• atan
• atan2
• atanh
• avg
• between
• bit_and
• bit_count
• bit_length
• bit_or
• bit_position
• bit_xor
• bitstring
• bitstring_agg
• can_cast_implicitly
• cardinality
• cast_to_type
• ceiling
• char_length
• character_length
• coalesce
• col_description
• collate
• combine
• constant_or_null
• contains
• corr
• count_if
• countif
• covar_pop
• covar_samp
• create_sort_key
• cume_dist
• currval
• decode
• dense_rank
• element_at
• encode
• entropy_shannon
• enum
• equi_width_bins
• error
• even
• factorial
• favg
• fdiv
• fill
• finalize
• first_value
• fmod
• format_pg_type
• format_type
• from_json_strict
• fsum
• gamma
• gcd
• generate_subscripts
• geo
• geomean
• geometric_mean
• get_bit
• get_block_size
• get_type
• getvariable
• greatest
• greatest_common_divisor
• group_concat
• hex
• histogram
• histogram_exact
• in_search_path
• inner
• is_histogram_other_bin
• is_inf
• is_not_in
• json
• kahan_sum
• kurtosis_fisher
• kurtosis_pop
• kurtosis_samp
• lag
• last_value
• lcm
• lead
• least
• least_common_multiple
• length
• lgamma
• listagg
• ln
• log2
• mad
• make_type
• map
• md5
• md5_number
• md5_number_lower
• md5_number_upper
• new
• nextafter
• nextval
• nth_value
• ntile
• nullif
• obj_description
• octet_length
• order_by
• parse_delta_filter_logline
• parse_duckdb_log_message
• percent_rank
• power
• quantile_cont
• quantile_disc
• radd
• rand
• re
• regr_avgx
• regr_avgy
• regr_count
• regr_intercept
• regr_r2
• regr_slope
• regr_sxx
• regr_sxy
• regr_syy
• remap_struct
• repeat
• replace_type
• reservoir_quantile
• rfloordiv
• rmod
• rmul
• ror
• round_even
• round_from_zero
• roundbankers
• row
• row_number
• row_to_json
• rpow
• rsub
• rtruediv
• sem
• set_bit
• setseed
• sha1
• sha256
• shobj_description
• show
• signbit
• skewness
• sleep_ms
• split_part
• stats
• stddev
• stddev_pop
• stddev_samp
• sum_no_overflow
• sumkahan
• switch
• to_binary
• to_hex
• to_json
• to_map
• trunc
• try_strptime
• typeof
• union_extract
• union_tag
• union_value
• uuid_extract_timestamp
• uuid_extract_version
• var_pop
• var_samp
• variance
• variant_extract
• variant_normalize
• variant_to_parquet_variant
• variant_typeof
• vector_type
• wavg
• weighted_avg
• window
• write_blob
• write_log

LazyGroupBy

[x] Missing Methods (4)

• having
  • Polars: (*predicates: IntoExpr | Iterable[IntoExpr]) -> LazyGroupBy
• head
  • Polars: (n: int) -> LazyFrame
• map_groups
  • Polars: (function: Callable[[DataFrame], DataFrame], schema: SchemaDict | None) -> LazyFrame
• tail
  • Polars: (n: int) -> LazyFrame

[!] Signature Mismatches (2)

• first
  • Polars: (ignore_nulls: bool) -> LazyFrame
  • belugas: () -> LazyFrame
• last
  • Polars: (ignore_nulls: bool) -> LazyFrame
  • belugas: () -> LazyFrame

ExprStringNameSpace

[x] Missing Methods (10)

• contains_any
  • Polars: (patterns: IntoExpr, ascii_case_insensitive: bool) -> Expr
• decode
  • Polars: (encoding: TransferEncoding, strict: bool) -> Expr
• extract_groups
  • Polars: (pattern: str) -> Expr
• extract_many
  • Polars: (patterns: IntoExpr, ascii_case_insensitive: bool, overlapping: bool, leftmost: bool) -> Expr
• find_many
  • Polars: (patterns: IntoExpr, ascii_case_insensitive: bool, overlapping: bool, leftmost: bool) -> Expr
• json_decode
  • Polars: (dtype: DataTypeExpr, infer_schema_length: int | None) -> Expr
• replace_many
  • Polars: (patterns: IntoExpr | Mapping[str, str], replace_with: IntoExpr | NoDefault, ascii_case_insensitive: bool, leftmost: bool) -> Expr
• split_exact
  • Polars: (by: IntoExpr, n: int, inclusive: bool) -> Expr
• splitn
  • Polars: (by: IntoExpr, n: int) -> Expr
• to_integer
  • Polars: (base: int | IntoExprColumn, dtype: PolarsIntegerType, strict: bool) -> Expr

[!] Signature Mismatches (23)

• concat
  • Polars: (delimiter: str | None, ignore_nulls: bool) -> Expr
  • belugas: (*args: IntoExpr) -> Expr
• contains
  • Polars: (pattern: str | Expr, literal: bool, strict: bool) -> Expr
  • belugas: (search_string: IntoExprColumn) -> T
• count_matches
  • Polars: (pattern: str | Expr, literal: bool) -> Expr
  • belugas: (pattern: IntoExprColumn, literal: bool) -> Expr
• ends_with
  • Polars: (suffix: str | Expr) -> Expr
  • belugas: (search_string: IntoExprColumn) -> T
• extract_all
  • Polars: (pattern: str | Expr) -> Expr
  • belugas: (pattern: IntoExprColumn) -> Expr
• find
  • Polars: (pattern: str | Expr, literal: bool, strict: bool) -> Expr
  • belugas: (pattern: IntoExprColumn, literal: bool) -> Expr
• head
  • Polars: (n: int | IntoExprColumn) -> Expr
  • belugas: (n: int) -> Expr
• normalize
  • Polars: (form: UnicodeForm) -> Expr
  • belugas: () -> Expr
• pad_end
  • Polars: (length: int | IntoExprColumn, fill_char: str) -> Expr
  • belugas: (length: int, fill_char: IntoExprColumn) -> Expr
• pad_start
  • Polars: (length: int | IntoExprColumn, fill_char: str) -> Expr
  • belugas: (length: int, fill_char: IntoExprColumn) -> Expr
• replace
  • Polars: (pattern: str | Expr, value: str | Expr, literal: bool, n: int) -> Expr
  • belugas: (source: IntoExprColumn, target: IntoExprColumn) -> T
• replace_all
  • Polars: (pattern: str | Expr, value: str | Expr, literal: bool) -> Expr
  • belugas: (pattern: IntoExprColumn, value: IntoExprColumn, literal: bool) -> Expr
• slice
  • Polars: (offset: int | IntoExprColumn, length: int | IntoExprColumn | None) -> Expr
  • belugas: (offset: int, length: int | None) -> Expr
• split
  • Polars: (by: IntoExpr, inclusive: bool, literal: bool, strict: bool) -> Expr
  • belugas: (separator: IntoExprColumn) -> T
• starts_with
  • Polars: (prefix: str | Expr) -> Expr
  • belugas: (search_string: IntoExprColumn) -> T
• strip_chars
  • Polars: (characters: IntoExpr) -> Expr
  • belugas: (characters: IntoExprColumn | None) -> Expr
• strip_chars_end
  • Polars: (characters: IntoExpr) -> Expr
  • belugas: (characters: IntoExprColumn | None) -> Expr
• strip_chars_start
  • Polars: (characters: IntoExpr) -> Expr
  • belugas: (characters: IntoExprColumn | None) -> Expr
• strptime
  • Polars: (dtype: PolarsTemporalType, format: str | None, strict: bool, exact: bool, cache: bool, ambiguous: Ambiguous | Expr) -> Expr
  • belugas: (format_arg: IntoExprColumn | SeqLiteral[str]) -> T
• tail
  • Polars: (n: int | IntoExprColumn) -> Expr
  • belugas: (n: int) -> Expr
• to_date
  • Polars: (format: str | None, strict: bool, exact: bool, cache: bool) -> Expr
  • belugas: (format: IntoExprColumn | None) -> Expr
• to_datetime
  • Polars: (format: str | None, time_unit: TimeUnit | None, time_zone: str | None, strict: bool, exact: bool, cache: bool, ambiguous: Ambiguous | Expr) -> Expr
  • belugas: (format: IntoExprColumn | None) -> Expr
• to_time
  • Polars: (format: str | None, strict: bool, cache: bool) -> Expr
  • belugas: (format: IntoExprColumn | None) -> Expr

[+] Extra Methods (belugas-only) (84)

• agg
• ascii
• bar
• base64
• bin
• bit_length
• char_length
• character_length
• chr
• concat_ws
• damerau_levenshtein
• editdist3
• format
• format_bytes
• formatreadabledecimalsize
• formatreadablesize
• from_base64
• from_binary
• from_hex
• hamming
• hash
• hex
• ilike_escape
• inner
• instr
• jaccard
• jaro_similarity
• jaro_winkler_similarity
• lcase
• left
• left_grapheme
• len
• length
• length_grapheme
• levenshtein
• like_escape
• lower
• lpad
• ltrim
• md5
• md5_number
• mismatches
• nfc_normalize
• not_ilike_escape
• not_like_escape
• ord
• parse_dirname
• parse_dirpath
• parse_filename
• parse_formatted_bytes
• parse_path
• position
• prefix
• printf
• repeat
• right
• right_grapheme
• rpad
• rtrim
• sha1
• sha256
• split_regex
• strftime
• strip_accents
• strlen
• strpos
• substr
• substring
• substring_grapheme
• suffix
• to_array
• to_base
• to_base64
• to_binary
• to_hex
• translate
• trim
• ucase
• unbin
• unhex
• unicode
• upper
• url_decode
• url_encode

ExprListNameSpace

[x] Missing Methods (15)

• agg
  • Polars: (expr: Expr) -> Expr
• arg_max
  • Polars: () -> Expr
• arg_min
  • Polars: () -> Expr
• diff
  • Polars: (n: int, null_behavior: NullBehavior) -> Expr
• gather
  • Polars: (indices: Expr | Series | list[int] | list[list[int]], null_on_oob: bool) -> Expr
• gather_every
  • Polars: (n: int | IntoExprColumn, offset: int | IntoExprColumn) -> Expr
• item
  • Polars: (allow_empty: bool) -> Expr
• sample
  • Polars: (n: int | IntoExprColumn | None, fraction: float | IntoExprColumn | None, with_replacement: bool, shuffle: bool, seed: int | None) -> Expr
• set_difference
  • Polars: (other: IntoExpr | Collection[Any]) -> Expr
• set_intersection
  • Polars: (other: IntoExpr | Collection[Any]) -> Expr
• set_symmetric_difference
  • Polars: (other: IntoExpr | Collection[Any]) -> Expr
• set_union
  • Polars: (other: IntoExpr | Collection[Any]) -> Expr
• shift
  • Polars: (n: int | IntoExprColumn) -> Expr
• to_array
  • Polars: (width: int) -> Expr
• to_struct
  • Polars: (n_field_strategy: ListToStructWidthStrategy | None, fields: Sequence[str] | Callable[[int], str] | None, upper_bound: int | None) -> Expr

[!] Signature Mismatches (10)

• all
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Expr
• any
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Expr
• concat
  • Polars: (other: list[Expr | str] | Expr | str | Series | list[Any]) -> Expr
  • belugas: (*args: IntoExpr) -> T
• contains
  • Polars: (item: IntoExpr, nulls_equal: bool) -> Expr
  • belugas: (element: IntoExpr) -> T
• count_matches
  • Polars: (element: IntoExpr) -> Expr
  • belugas: (elem: IntoExpr) -> Expr
• explode
  • Polars: (empty_as_null: bool, keep_nulls: bool) -> Expr
  • belugas: () -> Expr
• filter
  • Polars: (predicate: Expr) -> Expr
  • belugas: (lambda_arg: IntoExprColumn) -> Expr
• get
  • Polars: (index: int | Expr | str, null_on_oob: bool) -> Expr
  • belugas: (index: int) -> Expr
• slice
  • Polars: (offset: int | str | Expr, length: int | str | Expr | None) -> Expr
  • belugas: (begin: IntoExpr, end: IntoExpr, step: IntoExprColumn | int | None) -> T
• unique
  • Polars: (maintain_order: bool) -> Expr
  • belugas: () -> Expr

[+] Extra Methods (belugas-only) (62)

• aggr
• aggregate
• any_value
• append
• apply
• approx_count_distinct
• avg
• bit_and
• bit_or
• bit_xor
• bool_and
• bool_or
• cat
• char_length
• character_length
• cosine_distance
• cosine_similarity
• count
• distance
• distinct
• dot_product
• element
• entropy
• extract
• flatten
• grade_up
• has
• has_all
• has_any
• histogram
• indexof
• inner
• inner_product
• intersect
• kurtosis
• kurtosis_pop
• length
• mad
• mode
• negative_dot_product
• negative_inner_product
• pack
• position
• prepend
• product
• range
• reduce
• resize
• reverse_sort
• select
• sem
• skewness
• stddev_pop
• stddev_samp
• string_agg
• transform
• unpivot_list
• value
• var_pop
• var_samp
• where
• zip

ExprStructNameSpace

[x] Missing Methods (2)

• rename_fields
  • Polars: (names: Sequence[str]) -> Expr
• unnest
  • Polars: () -> Expr

[!] Signature Mismatches (1)

• field
  • Polars: (name: str | list[str], *more_names: str) -> Expr
  • belugas: (name: str) -> Expr

[+] Extra Methods (belugas-only) (13)

• concat
• contains
• extract
• extract_at
• has
• indexof
• inner
• insert
• keys
• pack
• position
• update
• values

ExprNameNameSpace

[x] Missing Methods (3)

• map_fields
  • Polars: (function: Callable[[str], str]) -> Expr
• prefix_fields
  • Polars: (prefix: str) -> Expr
• suffix_fields
  • Polars: (suffix: str) -> Expr

[!] Signature Mismatches (1)

• map
  • Polars: (function: Callable[[str], str]) -> Expr
  • belugas: (function: AliasFn) -> Expr

[+] Extra Methods (belugas-only) (1)

• inner

ExprArrayNameSpace

[x] Missing Methods (5)

• arg_max
  • Polars: () -> Expr
• arg_min
  • Polars: () -> Expr
• shift
  • Polars: (n: int | IntoExprColumn) -> Expr
• to_list
  • Polars: () -> Expr
• to_struct
  • Polars: (fields: Sequence[str] | Callable[[int], str] | None) -> Expr

[!] Signature Mismatches (12)

• agg
  • Polars: (expr: Expr) -> Expr
  • belugas: () -> T
• all
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Expr
• any
  • Polars: (ignore_nulls: bool) -> Expr
  • belugas: () -> Expr
• contains
  • Polars: (item: IntoExpr, nulls_equal: bool) -> Expr
  • belugas: (element: IntoExpr) -> T
• count_matches
  • Polars: (element: IntoExpr) -> Expr
  • belugas: (elem: IntoExpr) -> Expr
• eval
  • Polars: (expr: Expr, as_list: bool) -> Expr
  • belugas: (expr: Expr) -> Expr
• explode
  • Polars: (empty_as_null: bool, keep_nulls: bool) -> Expr
  • belugas: () -> Expr
• get
  • Polars: (index: int | IntoExprColumn, null_on_oob: bool) -> Expr
  • belugas: (index: int) -> Expr
• head
  • Polars: (n: int | str | Expr, as_array: bool) -> Expr
  • belugas: (n: int | str | Expr) -> Expr
• slice
  • Polars: (offset: int | str | Expr, length: int | str | Expr | None, as_array: bool) -> Expr
  • belugas: (begin: IntoExpr, end: IntoExpr, step: IntoExprColumn | int | None) -> T
• tail
  • Polars: (n: int | str | Expr, as_array: bool) -> Expr
  • belugas: (n: int | str | Expr) -> Expr
• unique
  • Polars: (maintain_order: bool) -> Expr
  • belugas: () -> Expr

[+] Extra Methods (belugas-only) (44)

• aggr
• aggregate
• append
• apply
• cat
• concat
• cosine_distance
• cosine_similarity
• cross_product
• distance
• distinct
• dot_product
• drop_nulls
• extract
• filter
• grade_up
• has
• has_all
• has_any
• indexof
• inner
• inner_product
• intersect
• length
• length_dimension
• negative_dot_product
• negative_inner_product
• pop_back
• pop_front
• position
• prepend
• push_back
• push_front
• reduce
• resize
• reverse_sort
• select
• to_json
• to_string
• to_string_comma_default
• transform
• value
• where
• zip

ExprDateTimeNameSpace

[x] Missing Methods (18)

• add_business_days
  • Polars: (n: int | IntoExpr, week_mask: Iterable[bool], holidays: Iterable[dt.date] | Expr | pl.Series, roll: Roll) -> Expr
• base_utc_offset
  • Polars: () -> Expr
• cast_time_unit
  • Polars: (time_unit: TimeUnit) -> Expr
• combine
  • Polars: (time: time | Expr, time_unit: TimeUnit) -> Expr
• convert_time_zone
  • Polars: (time_zone: str) -> Expr
• dst_offset
  • Polars: () -> Expr
• is_business_day
  • Polars: (week_mask: Iterable[bool], holidays: Iterable[dt.date] | Expr | pl.Series) -> Expr
• is_leap_year
  • Polars: () -> Expr
• replace
  • Polars: (year: int | IntoExpr | None, month: int | IntoExpr | None, day: int | IntoExpr | None, hour: int | IntoExpr | None, minute: int | IntoExpr | None, second: int | IntoExpr | None, microsecond: int | IntoExpr | None, ambiguous: Ambiguous | Expr) -> Expr
• replace_time_zone
  • Polars: (time_zone: str | None, ambiguous: Ambiguous | Expr, non_existent: NonExistent) -> Expr
• strftime
  • Polars: (format: str) -> Expr
• total_days
  • Polars: (fractional: bool) -> Expr
• total_hours
  • Polars: (fractional: bool) -> Expr
• total_microseconds
  • Polars: (fractional: bool) -> Expr
• total_milliseconds
  • Polars: (fractional: bool) -> Expr
• total_minutes
  • Polars: (fractional: bool) -> Expr
• total_nanoseconds
  • Polars: (fractional: bool) -> Expr
• total_seconds
  • Polars: (fractional: bool) -> Expr

[!] Signature Mismatches (6)

• epoch
  • Polars: (time_unit: EpochTimeUnit) -> Expr
  • belugas: () -> T
• offset_by
  • Polars: (by: str | Expr) -> Expr
  • belugas: (by: IntoExpr) -> Expr
• round
  • Polars: (every: timedelta | IntoExprColumn) -> Expr
  • belugas: (every: str) -> Expr
• second
  • Polars: (fractional: bool) -> Expr
  • belugas: () -> T
• to_string
  • Polars: (format: str | None) -> Expr
  • belugas: (format: IntoExprColumn) -> Expr
• truncate
  • Polars: (every: timedelta | Expr) -> Expr
  • belugas: (every: str) -> Expr

[+] Extra Methods (belugas-only) (52)

• add
• dayname
• dayofmonth
• dayofweek
• dayofyear
• decade
• diff
• epoch_by
• epoch_ms
• epoch_ns
• epoch_us
• era
• inner
• isodow
• isoyear
• julian
• last_day
• make_date
• make_date_month_day
• make_time
• make_timestamp
• make_timestamp_ms
• make_timestamp_ns
• make_timestamptz
• monthname
• normalized_interval
• part
• sub
• time_bucket
• timetz_byte_comparable
• timezone
• timezone_hour
• timezone_minute
• to_centuries
• to_datetime
• to_days
• to_decades
• to_hours
• to_microseconds
• to_millennia
• to_milliseconds
• to_minutes
• to_months
• to_quarters
• to_seconds
• to_time
• to_timestamp
• to_weeks
• to_years
• trunc
• weekofyear
• yearweek

ModuleFunctions

[x] Missing Methods (104)

• BaseExtension
  • Polars: (name: str, storage: PolarsDataType, metadata: str | None) -> None
• Catalog
  • Polars: (workspace_url: str, bearer_token: str | None, require_https: bool) -> None
• CompatLevel
  • Polars: () -> None
• DataTypeExpr
  • Polars: ()
• Extension
  • Polars: (name: str, storage: PolarsDataType, metadata: str | None) -> None
• Field
  • Polars: (name: str, dtype: PolarsDataType) -> None
• Float16
  • Polars: ()
• Object
  • Polars: ()
• ScanCastOptions
  • Polars: (integer_cast: Literal['forbid'] | IntegerCastOption | Collection[IntegerCastOption], float_cast: Literal['forbid'] | FloatCastOption | Collection[FloatCastOption], datetime_cast: Literal['forbid'] | DatetimeCastOption | Collection[DatetimeCastOption], missing_struct_fields: Literal['insert', 'raise'], extra_struct_fields: Literal['ignore', 'raise'], categorical_to_string: Literal['allow', 'forbid'],_internal_call: bool) -> None
• Schema
  • Polars: (schema: Mapping[str, SchemaInitDataType] | Iterable[tuple[str, SchemaInitDataType] | ArrowSchemaExportable] | ArrowSchemaExportable | None, check_dtypes: bool) -> None
• Unknown
  • Polars: ()
• align_frames
  • Polars: (*frames: FrameType | Iterable[FrameType], on: str | Expr | Sequence[str] | Sequence[Expr] | Sequence[str | Expr], how: JoinStrategy, select: str | Expr | Sequence[str | Expr] | None, descending: bool | Sequence[bool]) -> list[FrameType]
• arg_sort_by
  • Polars: (exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr, descending: bool | Sequence[bool], nulls_last: bool | Sequence[bool], multithreaded: bool, maintain_order: bool) -> Expr
• arg_where
  • Polars: (condition: Expr | Series, eager: bool) -> Expr | Series
• build_info
  • Polars: () -> dict[str, Any]
• business_day_count
  • Polars: (start: date | IntoExprColumn, end: date | IntoExprColumn, week_mask: Iterable[bool], holidays: Iterable[date] | Expr | Series) -> Expr
• collect_all
  • Polars: (lazy_frames: Iterable[LazyFrame], type_coercion: bool, predicate_pushdown: bool, projection_pushdown: bool, simplify_expression: bool, no_optimization: bool, slice_pushdown: bool, comm_subplan_elim: bool, comm_subexpr_elim: bool, cluster_with_columns: bool, collapse_joins: bool, optimizations: QueryOptFlags, engine: EngineType, lazy: bool) -> list[DataFrame] | LazyFrame
• collect_all_async
  • Polars: (lazy_frames: Iterable[LazyFrame], gevent: bool, engine: EngineType, optimizations: QueryOptFlags) -> Awaitable[list[DataFrame]] |_GeventDataFrameResult[list[DataFrame]]
• concat
  • Polars: (items: Iterable[PolarsType], how: ConcatMethod, rechunk: bool, parallel: bool, strict: bool) -> PolarsType
• concat_arr
  • Polars: (exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr) -> Expr
• concat_list
  • Polars: (exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr) -> Expr
• concat_str
  • Polars: (exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr, separator: str, ignore_nulls: bool) -> Expr
• corr
  • Polars: (a: IntoExpr, b: IntoExpr, method: CorrelationMethod, ddof: int | None, propagate_nans: bool, eager: bool) -> Expr | Series
• cov
  • Polars: (a: IntoExpr, b: IntoExpr, ddof: int, eager: bool) -> Expr | Series
• cum_fold
  • Polars: (acc: IntoExpr, function: Callable[[Series, Series], Series], exprs: Sequence[Expr | str] | Expr, returns_scalar: bool, return_dtype: DataTypeExpr | PolarsDataType | None, include_init: bool) -> Expr
• cum_reduce
  • Polars: (function: Callable[[Series, Series], Series], exprs: Sequence[Expr | str] | Expr, returns_scalar: bool, return_dtype: DataTypeExpr | PolarsDataType | None) -> Expr
• cum_sum_horizontal
  • Polars: (*exprs: IntoExpr | Iterable[IntoExpr]) -> Expr
• date
  • Polars: (year: Expr | str | int, month: Expr | str | int, day: Expr | str | int) -> Expr
• date_range
  • Polars: (start: date | datetime | IntoExprColumn, end: date | datetime | IntoExprColumn, interval: str | timedelta, closed: ClosedInterval, eager: bool) -> Series | Expr
• date_ranges
  • Polars: (start: date | datetime | IntoExprColumn, end: date | datetime | IntoExprColumn, interval: str | timedelta, closed: ClosedInterval, eager: bool) -> Series | Expr
• datetime
  • Polars: (year: int | IntoExpr, month: int | IntoExpr, day: int | IntoExpr, hour: int | IntoExpr | None, minute: int | IntoExpr | None, second: int | IntoExpr | None, microsecond: int | IntoExpr | None, time_unit: TimeUnit, time_zone: str | None, ambiguous: Ambiguous | Expr) -> Expr
• datetime_range
  • Polars: (start: datetime | date | IntoExprColumn, end: datetime | date | IntoExprColumn, interval: str | timedelta, closed: ClosedInterval, time_unit: TimeUnit | None, time_zone: str | None, eager: bool) -> Series | Expr
• datetime_ranges
  • Polars: (start: datetime | date | IntoExprColumn, end: datetime | date | IntoExprColumn, interval: str | timedelta, closed: ClosedInterval, time_unit: TimeUnit | None, time_zone: str | None, eager: bool) -> Series | Expr
• defer
  • Polars: (function: Callable[[], DataFrame], schema: SchemaDict | Callable[[], SchemaDict], validate_schema: bool) -> LazyFrame
• dtype_of
  • Polars: (col_or_expr: str | Expr) -> DataTypeExpr
• duration
  • Polars: (weeks: Expr | str | int | float | None, days: Expr | str | int | float | None, hours: Expr | str | int | float | None, minutes: Expr | str | int | float | None, seconds: Expr | str | int | float | None, milliseconds: Expr | str | int | float | None, microseconds: Expr | str | int | float | None, nanoseconds: Expr | str | int | float | None, time_unit: TimeUnit | None) -> Expr
• escape_regex
  • Polars: (s: str) -> str
• exclude
  • Polars: (columns: str | PolarsDataType | Collection[str] | Collection[PolarsDataType], *more_columns: str | PolarsDataType) -> Expr
• explain_all
  • Polars: (lazy_frames: Iterable[LazyFrame], optimizations: QueryOptFlags) -> str
• field
  • Polars: (name: str | list[str]) -> Expr
• fold
  • Polars: (acc: IntoExpr, function: Callable[[Series, Series], Series], exprs: Sequence[Expr | str] | Expr, returns_scalar: bool, return_dtype: DataTypeExpr | PolarsDataType | None) -> Expr
• format
  • Polars: (f_string: str, *args: IntoExpr) -> Expr
• from_dataframe
  • Polars: (df: SupportsInterchange | ArrowArrayExportable | ArrowStreamExportable, allow_copy: bool | None, rechunk: bool) -> DataFrame
• from_epoch
  • Polars: (column: str | Expr | Series | Sequence[int | float], time_unit: EpochTimeUnit) -> Expr | Series
• from_repr
  • Polars: (data: str) -> DataFrame | Series
• from_torch
  • Polars: (tensor: Tensor, schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, orient: Orientation | None, force: bool) -> DataFrame
• get_index_type
  • Polars: () -> PolarsIntegerType
• groups
  • Polars: (column: str) -> Expr
• head
  • Polars: (column: str, n: int) -> Expr
• implode
  • Polars: (*columns: str, maintain_order: bool) -> Expr
• int_range
  • Polars: (start: int | IntoExprColumn, end: int | IntoExprColumn | None, step: int, dtype: PolarsIntegerType | DataTypeExpr, eager: bool) -> Expr | Series
• int_ranges
  • Polars: (start: int | IntoExprColumn, end: int | IntoExprColumn | None, step: int | IntoExprColumn, dtype: PolarsIntegerType | DataTypeExpr, eager: bool) -> Expr | Series
• json_normalize
  • Polars: (data: dict[Any, Any] | Sequence[dict[Any, Any] | Any], separator: str, max_level: int | None, schema: Schema | None, strict: bool, infer_schema_length: int | None, encoder: JSONEncoder | None) -> DataFrame
• linear_space
  • Polars: (start: NumericLiteral | TemporalLiteral | IntoExpr, end: NumericLiteral | TemporalLiteral | IntoExpr, num_samples: int | IntoExpr, closed: ClosedInterval, eager: bool) -> Expr | Series
• linear_spaces
  • Polars: (start: NumericLiteral | TemporalLiteral | IntoExprColumn, end: NumericLiteral | TemporalLiteral | IntoExprColumn, num_samples: int | IntoExprColumn, closed: ClosedInterval, as_array: bool, eager: bool) -> Expr | Series
• map_batches
  • Polars: (exprs: Sequence[str | Expr], function: Callable[[Sequence[Series]], Series | Any], return_dtype: DataTypeExpr | None, is_elementwise: bool, returns_scalar: bool) -> Expr
• map_groups
  • Polars: (exprs: Sequence[str | Expr], function: Callable[[Sequence[Series]], Series | Any], return_dtype: DataTypeExpr | None, is_elementwise: bool, returns_scalar: bool) -> Expr
• merge_sorted
  • Polars: (items: Iterable[PolarsType], key: str, maintain_order: bool) -> PolarsType
• nth
  • Polars: (*indices: int | Sequence[int], strict: bool) -> Expr
• ones
  • Polars: (n: int | Expr, dtype: PolarsDataType, eager: bool) -> Expr | Series
• quantile
  • Polars: (column: str, quantile: float | Expr, interpolation: QuantileMethod) -> Expr
• read_avro
  • Polars: (source: str | Path | IO[bytes] | bytes, columns: list[int] | list[str] | None, n_rows: int | None) -> DataFrame
• read_clipboard
  • Polars: (separator: str, **kwargs: Any) -> DataFrame
• read_csv
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes, has_header: bool, columns: Sequence[int] | Sequence[str] | None, new_columns: Sequence[str] | None, separator: str, comment_prefix: str | None, quote_char: str | None, skip_rows: int, skip_lines: int, schema: SchemaDict | None, schema_overrides: Mapping[str, PolarsDataType] | Sequence[PolarsDataType] | None, null_values: str | Sequence[str] | dict[str, str] | None, missing_utf8_is_empty_string: bool, ignore_errors: bool, try_parse_dates: bool, n_threads: int | None, infer_schema: bool, infer_schema_length: int | None, batch_size: int, n_rows: int | None, encoding: CsvEncoding | str, low_memory: bool, rechunk: bool, use_pyarrow: bool, storage_options: StorageOptionsDict | None, skip_rows_after_header: int, row_index_name: str | None, row_index_offset: int, sample_size: int, eol_char: str, raise_if_empty: bool, truncate_ragged_lines: bool, decimal_comma: bool, glob: bool) -> DataFrame
• read_database
  • Polars: (query: str | TextClause | Selectable, connection: ConnectionOrCursor | str, iter_batches: bool, batch_size: int | None, schema_overrides: SchemaDict | None, infer_schema_length: int | None, execute_options: dict[str, Any] | None) -> DataFrame | Iterator[DataFrame]
• read_database_uri
  • Polars: (query: list[str] | str, uri: str, partition_on: str | None, partition_range: tuple[int, int] | None, partition_num: int | None, protocol: str | None, engine: DbReadEngine | None, schema_overrides: SchemaDict | None, execute_options: dict[str, Any] | None, pre_execution_query: str | list[str] | None) -> DataFrame
• read_delta
  • Polars: (source: str | Path | DeltaTable, version: int | str | datetime | None, columns: list[str] | None, rechunk: bool | None, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, delta_table_options: dict[str, Any] | None, use_pyarrow: bool, pyarrow_options: dict[str, Any] | None) -> DataFrame
• read_excel
  • Polars: (source: FileSource | memoryview[int], sheet_id: int | Sequence[int] | None, sheet_name: str | list[str] | tuple[str, ...] | None, table_name: str | None, engine: ExcelSpreadsheetEngine, engine_options: dict[str, Any] | None, read_options: dict[str, Any] | None, has_header: bool, columns: Sequence[int] | Sequence[str] | str | None, schema_overrides: SchemaDict | None, infer_schema_length: int | None, include_file_paths: str | None, drop_empty_rows: bool, drop_empty_cols: bool, raise_if_empty: bool) -> DataFrame | dict[str, pl.DataFrame]
• read_ipc
  • Polars: (source: str | Path | IO[bytes] | bytes, columns: list[int] | list[str] | None, n_rows: int | None, use_pyarrow: bool, memory_map: bool, storage_options: StorageOptionsDict | None, row_index_name: str | None, row_index_offset: int, rechunk: bool) -> DataFrame
• read_ipc_schema
  • Polars: (source: str | Path | IO[bytes] | bytes) -> dict[str, DataType]
• read_ipc_stream
  • Polars: (source: str | Path | IO[bytes] | bytes, columns: list[int] | list[str] | None, n_rows: int | None, use_pyarrow: bool, storage_options: StorageOptionsDict | None, row_index_name: str | None, row_index_offset: int, rechunk: bool) -> DataFrame
• read_json
  • Polars: (source: str | Path | IOBase | bytes, schema: SchemaDefinition | None, schema_overrides: SchemaDefinition | None, infer_schema_length: int | None) -> DataFrame
• read_lines
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes | list[str] | list[Path] | list[IO[str]] | list[IO[bytes]], name: str, n_rows: int | None, row_index_name: str | None, row_index_offset: int, glob: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, include_file_paths: str | None) -> DataFrame
• read_ndjson
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes | list[str] | list[Path] | list[IO[str]] | list[IO[bytes]], schema: SchemaDefinition | None, schema_overrides: SchemaDefinition | None, infer_schema_length: int | None, batch_size: int | None, n_rows: int | None, low_memory: bool, rechunk: bool, row_index_name: str | None, row_index_offset: int, ignore_errors: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, file_cache_ttl: int | None, include_file_paths: str | None) -> DataFrame
• read_ods
  • Polars: (source: FileSource, sheet_id: int | Sequence[int] | None, sheet_name: str | list[str] | tuple[str, ...] | None, has_header: bool, columns: Sequence[int] | Sequence[str] | None, schema_overrides: SchemaDict | None, infer_schema_length: int | None, include_file_paths: str | None, drop_empty_rows: bool, drop_empty_cols: bool, raise_if_empty: bool) -> DataFrame | dict[str, pl.DataFrame]
• read_parquet
  • Polars: (source: FileSource, columns: list[int] | list[str] | None, n_rows: int | None, row_index_name: str | None, row_index_offset: int, parallel: ParallelStrategy, use_statistics: bool, hive_partitioning: bool | None, glob: bool, schema: SchemaDict | None, hive_schema: SchemaDict | None, try_parse_hive_dates: bool, rechunk: bool, low_memory: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, use_pyarrow: bool, pyarrow_options: dict[str, Any] | None, memory_map: bool, include_file_paths: str | None, missing_columns: Literal['insert', 'raise'], allow_missing_columns: bool | None) -> DataFrame
• read_parquet_metadata
  • Polars: (source: str | Path | IO[bytes] | bytes, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None) -> dict[str, str]
• read_parquet_schema
  • Polars: (source: str | Path | IO[bytes] | bytes) -> dict[str, DataType]
• reduce
  • Polars: (function: Callable[[Series, Series], Series], exprs: Sequence[Expr | str] | Expr, returns_scalar: bool, return_dtype: DataTypeExpr | PolarsDataType | None) -> Expr
• register_extension_type
  • Polars: (ext_name: str, ext_class: type[dt.BaseExtension] | None, as_storage: bool) -> None
• repeat
  • Polars: (value: IntoExpr | None, n: int | Expr, dtype: PolarsDataType | None, eager: bool) -> Expr | Series
• rolling_corr
  • Polars: (a: str | Expr, b: str | Expr, window_size: int, min_samples: int | None, ddof: int) -> Expr
• rolling_cov
  • Polars: (a: str | Expr, b: str | Expr, window_size: int, min_samples: int | None, ddof: int) -> Expr
• row_index
  • Polars: (name: str) -> Expr
• scan_delta
  • Polars: (source: str | Path | DeltaTable, version: int | str | datetime | None, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, delta_table_options: dict[str, Any] | None, use_pyarrow: bool, pyarrow_options: dict[str, Any] | None, rechunk: bool | None) -> LazyFrame
• scan_iceberg
  • Polars: (source: Table, snapshot_id: int | None, storage_options: StorageOptionsDict | None, catalog: IcebergCatalogConfig | None, reader_override: Literal['native', 'pyiceberg'] | None, use_metadata_statistics: bool, fast_deletion_count: bool | None, use_pyiceberg_filter: bool) -> LazyFrame
• scan_ipc
  • Polars: (source: str | Path | IO[bytes] | bytes | list[str] | list[Path] | list[IO[bytes]] | list[bytes], n_rows: int | None, cache: bool | None, rechunk: bool, row_index_name: str | None, row_index_offset: int, glob: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, memory_map: bool, retries: int | None, file_cache_ttl: int | None, hive_partitioning: bool | None, hive_schema: SchemaDict | None, try_parse_hive_dates: bool, include_file_paths: str | None,_record_batch_statistics: bool) -> LazyFrame
• scan_lines
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes | list[str] | list[Path] | list[IO[str]] | list[IO[bytes]], name: str, n_rows: int | None, row_index_name: str | None, row_index_offset: int, glob: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, include_file_paths: str | None) -> LazyFrame
• scan_ndjson
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes | list[str] | list[Path] | list[IO[str]] | list[IO[bytes]], schema: SchemaDefinition | None, schema_overrides: SchemaDefinition | None, infer_schema_length: int | None, batch_size: int | None, n_rows: int | None, low_memory: bool, rechunk: bool, row_index_name: str | None, row_index_offset: int, ignore_errors: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, file_cache_ttl: int | None, include_file_paths: str | None) -> LazyFrame
• scan_pyarrow_dataset
  • Polars: (source: Dataset, allow_pyarrow_filter: bool, batch_size: int | None) -> LazyFrame
• select
  • Polars: (*exprs: IntoExpr | Iterable[IntoExpr], eager: bool, **named_exprs: IntoExpr) -> DataFrame | LazyFrame
• self_dtype
  • Polars: () -> DataTypeExpr
• set_random_seed
  • Polars: (seed: int) -> None
• sql
  • Polars: (query: str, eager: bool) -> DataFrame | LazyFrame
• sql_expr
  • Polars: (sql: str | Sequence[str]) -> Expr | list[Expr]
• struct
  • Polars: (*exprs: IntoExpr | Iterable[IntoExpr], schema: SchemaDict | None, eager: bool, **named_exprs: IntoExpr) -> Expr | Series
• struct_with_fields
  • Polars: (mapping: Mapping[str, PolarsDataType | pl.DataTypeExpr]) -> DataTypeExpr
• tail
  • Polars: (column: str, n: int) -> Expr
• thread_pool_size
  • Polars: () -> int
• time
  • Polars: (hour: Expr | str | int | None, minute: Expr | str | int | None, second: Expr | str | int | None, microsecond: Expr | str | int | None) -> Expr
• time_range
  • Polars: (start: time | IntoExprColumn | None, end: time | IntoExprColumn | None, interval: str | timedelta, closed: ClosedInterval, eager: bool) -> Series | Expr
• time_ranges
  • Polars: (start: time | IntoExprColumn | None, end: time | IntoExprColumn | None, interval: str | timedelta, closed: ClosedInterval, eager: bool) -> Series | Expr
• union
  • Polars: (items: Iterable[PolarsType], how: ConcatMethod, strict: bool) -> PolarsType
• zeros
  • Polars: (n: int | Expr, dtype: PolarsDataType, eager: bool) -> Expr | Series

[!] Signature Mismatches (37)

• Array
  • Polars: (inner: PolarsDataType | PythonDataType, shape: int | tuple[int, ...] | None, width: int | None) -> None
  • belugas: (inner: DataType, size: int) -> None
• Datetime
  • Polars: (time_unit: TimeUnit, time_zone: str | tzinfo | None) -> None
  • belugas: (time_unit: EpochTimeUnit) -> None
• Decimal
  • Polars: (precision: int | None, scale: int) -> None
  • belugas: (precision: int, scale: int) -> None
• Duration
  • Polars: (time_unit: TimeUnit) -> None
  • belugas: () -> None
• Enum
  • Polars: (categories: Series | Iterable[str] | type[enum.Enum]) -> None
  • belugas: (categories: Iterable[str] | type[PyEnum]) -> None
• Expr
  • Polars: ()
  • belugas: (_inner: T, aliaser: AliasMapper) -> None
• LazyFrame
  • Polars: (data: FrameInitTypes | None, schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, strict: bool, orient: Orientation | None, infer_schema_length: int | None, nan_to_null: bool, height: int | None) -> None
  • belugas: (data: IntoRel | Self, orient: Orientation, connection: DuckDBPyConnection | None) -> None
• List
  • Polars: (inner: PolarsDataType | PythonDataType) -> None
  • belugas: (inner: DataType) -> None
• Struct
  • Polars: (fields: Sequence[Field] | SchemaDict) -> None
  • belugas: (fields: IntoDict[str, DataType]) -> None
• all
  • Polars: (*names: str, ignore_nulls: bool) -> Expr
  • belugas: (exclude: TryIter[IntoExprColumn]) -> Expr
• approx_n_unique
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• arange
  • Polars: (start: int | IntoExprColumn, end: int | IntoExprColumn | None, step: int, dtype: PolarsIntegerType | DataTypeExpr, eager: bool) -> Expr | Series
  • belugas: (start: IntoExprColumn | datetime | int, stop: IntoExprColumn | datetime | int | None, step: IntoExprColumn | int | timedelta | None) -> Expr
• arctan2
  • Polars: (y: str | Expr, x: str | Expr) -> Expr
  • belugas: (y: IntoExprColumn | float, x: IntoExprColumn | float) -> Expr
• coalesce
  • Polars: (exprs: IntoExpr | Iterable[IntoExpr], *more_exprs: IntoExpr, eager: bool) -> Expr | Series
  • belugas: (exprs: TryIter[IntoExpr], *more_exprs: IntoExpr) -> Expr
• count
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• cum_count
  • Polars: (*columns: str, reverse: bool) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str, reverse: bool) -> Expr
• cum_sum
  • Polars: (*names: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• first
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• from_arrow
  • Polars: (data: RecordBatch | Iterable[pa.RecordBatch | pa.Table] | ArrowArrayExportable | ArrowStreamExportable, schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, rechunk: bool) -> DataFrame | Series
  • belugas: (df: IntoArrow, connection: Conn) -> LazyFrame
• from_dict
  • Polars: (data: Mapping[str, Sequence[object] | Mapping[str, Sequence[object]] | Series], schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, strict: bool) -> DataFrame
  • belugas: (mapping: IntoDict[str, PythonLiteral], connection: Conn) -> LazyFrame
• from_dicts
  • Polars: (data: Iterable[Mapping[str, Any]], schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, strict: bool, infer_schema_length: int | None) -> DataFrame
  • belugas: (data: Sequence[Mapping[str, PythonLiteral]], connection: Conn) -> LazyFrame
• from_numpy
  • Polars: (data: ndarray[Any, Any], schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, orient: Orientation | None) -> DataFrame
  • belugas: (arr: AnyArray, orient: Orientation, connection: Conn) -> LazyFrame
• from_pandas
  • Polars: (data: Series[Any] | pd.Index[Any] | pd.DatetimeIndex, schema_overrides: SchemaDict | None, rechunk: bool, nan_to_null: bool, include_index: bool) -> DataFrame | Series
  • belugas: (df: DataFrame, connection: Conn) -> LazyFrame
• from_records
  • Polars: (data: Sequence[Any], schema: SchemaDefinition | None, schema_overrides: SchemaDict | None, strict: bool, orient: Orientation | None, infer_schema_length: int | None) -> DataFrame
  • belugas: (data: SeqIntoVals, orient: Orientation, connection: Conn) -> LazyFrame
• last
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• lit
  • Polars: (value: Any, dtype: PolarsDataType | DataTypeExpr | None, allow_object: bool) -> Expr
  • belugas: (value: PythonLiteral) -> Expr
• max
  • Polars: (*names: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• mean
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• mean_horizontal
  • Polars: (*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr
  • belugas: (exprs: TryIter[IntoExpr], *more_exprs: IntoExpr) -> Expr
• median
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• min
  • Polars: (*names: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• n_unique
  • Polars: (*columns: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• scan_csv
  • Polars: (source: str | Path | IO[str] | IO[bytes] | bytes | list[str] | list[Path] | list[IO[str]] | list[IO[bytes]] | list[bytes], has_header: bool, separator: str, comment_prefix: str | None, quote_char: str | None, skip_rows: int, skip_lines: int, schema: SchemaDict | None, schema_overrides: SchemaDict | Sequence[PolarsDataType] | None, null_values: str | Sequence[str] | dict[str, str] | None, missing_utf8_is_empty_string: bool, ignore_errors: bool, cache: bool | None, with_column_names: Callable[[list[str]], list[str]] | None, infer_schema: bool, infer_schema_length: int | None, n_rows: int | None, encoding: CsvEncoding, low_memory: bool, rechunk: bool, skip_rows_after_header: int, row_index_name: str | None, row_index_offset: int, try_parse_dates: bool, eol_char: str, new_columns: Sequence[str] | None, raise_if_empty: bool, truncate_ragged_lines: bool, decimal_comma: bool, glob: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, file_cache_ttl: int | None, include_file_paths: str | None, missing_columns: Literal['insert', 'raise'] | None) -> LazyFrame
  • belugas: (path_or_buffer: PathOrBuffer, header: bool | int | None, compression: CsvCompression | None, sep: str | None, delimiter: str | None, files_to_sniff: int | None, comment: str | None, thousands: str | None, dtype: IntoFields | None, na_values: str | list[str] | None, skiprows: int | None, quotechar: str | None, escapechar: str | None, encoding: CsvEncoding | None, parallel: bool | None, date_format: str | None, timestamp_format: str | None, sample_size: int | None, auto_detect: bool | int | None, all_varchar: bool | None, normalize_names: bool | None, null_padding: bool | None, names: list[str] | None, lineterminator: CSVLineTerminator | None, columns: ColumnsTypes | None, auto_type_candidates: list[StrIntoPyType] | None, max_line_size: int | None, ignore_errors: bool | None, store_rejects: bool | None, rejects_table: str | None, rejects_scan: str | None, rejects_limit: int | None, force_not_null: list[str] | None, buffer_size: int | None, decimal: str | None, allow_quoted_nulls: bool | None, filename: bool | str | None, hive_partitioning: bool | None, union_by_name: bool | None, hive_types: HiveTypes | None, hive_types_autocast: bool | None, strict_mode: bool | None, connection: Conn) -> LazyFrame
• scan_parquet
  • Polars: (source: FileSource, n_rows: int | None, row_index_name: str | None, row_index_offset: int, parallel: ParallelStrategy, use_statistics: bool, hive_partitioning: bool | None, glob: bool, hidden_file_prefix: str | Sequence[str] | None, schema: SchemaDict | None, hive_schema: SchemaDict | None, try_parse_hive_dates: bool, rechunk: bool, low_memory: bool, cache: bool, storage_options: StorageOptionsDict | None, credential_provider: CredentialProviderFunction | Literal['auto'] | None, retries: int | None, include_file_paths: str | None, missing_columns: Literal['insert', 'raise'], allow_missing_columns: bool | None, extra_columns: Literal['ignore', 'raise'], cast_options: ScanCastOptions | None, _column_mapping: ColumnMapping | None, _default_values: DefaultFieldValues | None, _deletion_files: DeletionFiles | None, _table_statistics: DataFrame | None, _row_count: tuple[int, int] | None) -> LazyFrame
  • belugas: (file_glob: ParquetSource, binary_as_string: bool, file_row_number: bool, filename: bool, hive_partitioning: bool, union_by_name: bool, compression: ParquetCompression | None, connection: Conn) -> LazyFrame
• sum
  • Polars: (*names: str) -> Expr
  • belugas: (cols: TryIter[str], *more_cols: str) -> Expr
• sum_horizontal
  • Polars: (*exprs: IntoExpr | Iterable[IntoExpr], ignore_nulls: bool) -> Expr
  • belugas: (exprs: TryIter[IntoExpr], *more_exprs: IntoExpr) -> Expr
• when
  • Polars: (*predicates: IntoExprColumn | Iterable[IntoExprColumn] | bool, **constraints: Any) -> When
  • belugas: (predicates: TryIter[IntoExpr], *more_predicates: IntoExpr) -> When

[+] Extra Methods (belugas-only) (15)

• BitString
• DatetimeTZ
• Geometry
• Json
• Map
• Number
• TimeTZ
• UUID
• Union
• from_polars
• from_query
• from_table
• from_table_function
• generate_series
• scan_json

selectors

[x] Missing Methods (12)

• alpha
  • Polars: (ascii_only: bool, ignore_spaces: bool) -> Selector
• alphanumeric
  • Polars: (ascii_only: bool, ignore_spaces: bool) -> Selector
• array
  • Polars: (inner: Selector | None, width: int | None) -> Selector
• by_index
  • Polars: (*indices: int | range | Sequence[int | range], require_all: bool) -> Selector
• datetime
  • Polars: (time_unit: TimeUnit | Collection[TimeUnit] | None, time_zone: timezone | Collection[str | pydatetime.timezone | None] | None) -> Selector
• digit
  • Polars: (ascii_only: bool) -> Selector
• exclude
  • Polars: (columns: str | PolarsDataType | Selector | Expr | Collection[str | PolarsDataType | Selector | Expr], *more_columns: str | PolarsDataType | Selector | Expr) -> Selector
• expand_selector
  • Polars: (target: DataFrame | LazyFrame | Mapping[str, PolarsDataType], selector: Selector | Expr, strict: bool) -> tuple[str, ...]
• first
  • Polars: (strict: bool) -> Selector
• is_selector
  • Polars: (obj: Any) -> TypeIs[Selector]
• last
  • Polars: (strict: bool) -> Selector
• list
  • Polars: (inner: None | Selector) -> Selector

[!] Signature Mismatches (4)

• by_dtype
  • Polars: (*dtypes: PolarsDataType | PythonDataType | Iterable[PolarsDataType] | Iterable[PythonDataType]) -> Selector
  • belugas: (*dtypes: type[dt.DataType]) -> Selector
• by_name
  • Polars: (*names: str | Collection[str], require_all: bool) -> Selector
  • belugas: (*names: str) -> Selector
• duration
  • Polars: (time_unit: TimeUnit | Collection[TimeUnit] | None) -> Selector
  • belugas: () -> Selector
• string
  • Polars: (include_categorical: bool) -> Selector
  • belugas: () -> Selector

DataType

[x] Missing Methods (5)

• base_type
  • Polars: () -> type[Self]
• is_extension
  • Polars: () -> bool
• is_object
  • Polars: () -> bool
• to_dtype_expr
  • Polars: () -> DataTypeExpr
• to_python
  • Polars: () -> PythonDataType

[!] Signature Mismatches (2)

• from_python
  • Polars: (py_type: PythonDataType) -> PolarsDataType
  • belugas: (dtype: IntoPyType) -> DataType
• is_
  • Polars: (other: PolarsDataType) -> bool
  • belugas: (other: T) -> TypeIs[T]

[+] Extra Methods (belugas-only) (4)

• build
• from_duckdb
• from_sql
• from_str

Schema

[x] Missing Methods (19)

• clear
  • Polars: ()
• contains_dtype
  • Polars: (dtype: DataType, recursive: bool) -> bool
• copy
  • Polars: ()
• dtypes
  • Polars: () -> list[DataType]
• fromkeys
  • Polars: (iterable, value=...)
• get
  • Polars: (key, default=...)
• items
  • Polars: ()
• keys
  • Polars: ()
• len
  • Polars: () -> int
• move_to_end
  • Polars: (key, last=...)
• names
  • Polars: () -> list[str]
• pop
• popitem
  • Polars: (last=...)
• setdefault
  • Polars: (key, default=...)
• to_arrow
  • Polars: (compat_level: CompatLevel | None) -> Schema
• to_frame
  • Polars: (eager: bool) -> DataFrame | LazyFrame
• to_python
  • Polars: () -> dict[str, type]
• update
• values
  • Polars: ()