patito 0.5.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

patito/polars.py

@@ -1,13 +1,18 @@
 """Logic related to the wrapping of the polars data frame library."""
+
 from __future__ import annotations
 
 from typing import (
     TYPE_CHECKING,
     Any,
     Collection,
+    Dict,
     Generic,
     Iterable,
+    Literal,
     Optional,
+    Sequence,
+    Tuple,
     Type,
     TypeVar,
     Union,
@@ -16,9 +21,9 @@ from typing import (
 
 import polars as pl
 from polars.type_aliases import IntoExpr
-from pydantic import create_model
-from typing_extensions import Literal
+from pydantic import AliasChoices, AliasPath, create_model
 
+from patito._pydantic.column_info import ColumnInfo
 from patito.exceptions import MultipleRowsReturned, RowDoesNotExist
 
 if TYPE_CHECKING:
@@ -42,8 +47,7 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
     def _construct_lazyframe_model_class(
         cls: Type[LDF], model: Optional[Type[ModelType]]
     ) -> Type[LazyFrame[ModelType]]:
-        """
-        Return custom LazyFrame sub-class where LazyFrame.model is set.
+        """Return custom LazyFrame sub-class where LazyFrame.model is set.
 
         Can be used to construct a LazyFrame class where
         DataFrame.set_model(model) is implicitly invoked at collection.
@@ -55,12 +59,13 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
         Returns:
             A custom LazyFrame model class where LazyFrame.model has been correctly
                 "hard-coded" to the given model.
+
         """
         if model is None:
             return cls
 
         new_class = type(
-            f"{model.schema()['title']}LazyFrame",
+            f"{model.__name__}LazyFrame",
             (cls,),
             {"model": model},
         )
@@ -68,41 +73,232 @@ class LazyFrame(pl.LazyFrame, Generic[ModelType]):
 
     def collect(
         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,
-        common_subplan_elimination: bool = True,
-        streaming: bool = False,
+        *args,
+        **kwargs,
     ) -> "DataFrame[ModelType]":  # noqa: DAR101, DAR201
-        """
-        Collect into a DataFrame.
+        """Collect into a DataFrame.
 
         See documentation of polars.DataFrame.collect for full description of
         parameters.
         """
-        df = super().collect(
-            type_coercion=type_coercion,
-            predicate_pushdown=predicate_pushdown,
-            projection_pushdown=projection_pushdown,
-            simplify_expression=simplify_expression,
-            no_optimization=no_optimization,
-            slice_pushdown=slice_pushdown,
-            common_subplan_elimination=common_subplan_elimination,
-            streaming=streaming,
-        )
+        background = kwargs.pop("background", False)
+        df = super().collect(*args, background=background, **kwargs)
         if getattr(self, "model", False):
             cls = DataFrame._construct_dataframe_model_class(model=self.model)
         else:
             cls = DataFrame
         return cls._from_pydf(df._df)
 
+    def derive(self: LDF, columns: list[str] | None = None) -> LDF:
+        """Populate columns which have ``pt.Field(derived_from=...)`` definitions.
+
+        If a column field on the data frame model has ``patito.Field(derived_from=...)``
+        specified, the given value will be used to define the column. If
+        ``derived_from`` is set to a string, the column will be derived from the given
+        column name. Alternatively, an arbitrary polars expression can be given, the
+        result of which will be used to populate the column values.
+
+        Args:
+            columns: Optionally, a list of column names to derive. If not provided, all
+                columns are used.
+
+        Returns:
+            DataFrame[Model]: A new dataframe where all derivable columns are provided.
+
+        Raises:
+            TypeError: If the ``derived_from`` parameter of ``patito.Field`` is given
+                as something else than a string or polars expression.
+
+        Examples:
+            >>> import patito as pt
+            >>> import polars as pl
+            >>> class Foo(pt.Model):
+            ...     bar: int = pt.Field(derived_from="foo")
+            ...     double_bar: int = pt.Field(derived_from=2 * pl.col("bar"))
+            ...
+            >>> Foo.DataFrame({"foo": [1, 2]}).derive()
+            shape: (2, 3)
+            ┌─────┬────────────┬─────┐
+            │ bar ┆ double_bar ┆ foo │
+            │ --- ┆ ---        ┆ --- │
+            │ i64 ┆ i64        ┆ i64 │
+            ╞═════╪════════════╪═════╡
+            │ 1   ┆ 2          ┆ 1   │
+            │ 2   ┆ 4          ┆ 2   │
+            └─────┴────────────┴─────┘
+
+        """
+        derived_columns = []
+        props = self.model._schema_properties()
+        original_columns = set(self.columns)
+        to_derive = self.model.derived_columns if columns is None else columns
+        for column_name in to_derive:
+            if column_name not in derived_columns:
+                self, _derived_columns = self._derive_column(
+                    self, column_name, self.model.column_infos
+                )
+                derived_columns.extend(_derived_columns)
+        out_cols = [
+            x for x in props if x in original_columns.union(to_derive)
+        ]  # ensure that model columns are first and in the correct order
+        out_cols += [
+            x for x in original_columns.union(to_derive) if x not in out_cols
+        ]  # collect columns originally in data frame that are not in the model and append to end of df
+        return self.select(out_cols)
+
+    def _derive_column(
+        self,
+        df: LDF,
+        column_name: str,
+        column_infos: Dict[str, ColumnInfo],
+    ) -> Tuple[LDF, Sequence[str]]:
+        if (
+            column_infos.get(column_name, None) is None
+            or column_infos[column_name].derived_from is None
+        ):
+            return df, []
+        derived_from = column_infos[column_name].derived_from
+        dtype = self.model.dtypes[column_name]
+        derived_columns = []
+        if isinstance(derived_from, str):
+            df = df.with_columns(pl.col(derived_from).cast(dtype).alias(column_name))
+        elif isinstance(derived_from, pl.Expr):
+            root_cols = derived_from.meta.root_names()
+            while root_cols:
+                root_col = root_cols.pop()
+                df, _derived_columns = self._derive_column(df, root_col, column_infos)
+                derived_columns.extend(_derived_columns)
+            df = df.with_columns(derived_from.cast(dtype).alias(column_name))
+        else:
+            raise TypeError(
+                "Can not derive dataframe column from type " f"{type(derived_from)}."
+            )
+        derived_columns.append(column_name)
+        return df, derived_columns
+
+    def unalias(self: LDF) -> LDF:
+        """Un-aliases column names using information from pydantic validation_alias.
+
+        In order of preference - model field name then validation_aliases in order of occurrence
+
+        limitation - AliasChoice validation type only supports selecting a single element of an array
+
+        Returns:
+            DataFrame[Model]: A dataframe with columns normalized to model names.
+
+        """
+        if not any(fi.validation_alias for fi in self.model.model_fields.values()):
+            return self
+        exprs = []
+
+        def to_expr(va: str | AliasPath | AliasChoices) -> Optional[pl.Expr]:
+            if isinstance(va, str):
+                return pl.col(va) if va in self.columns else None
+            elif isinstance(va, AliasPath):
+                if len(va.path) != 2 or not isinstance(va.path[1], int):
+                    raise NotImplementedError(
+                        f"TODO figure out how this AliasPath behaves ({va})"
+                    )
+                return (
+                    pl.col(va.path[0]).list.get(va.path[1])
+                    if va.path[0] in self.columns
+                    else None
+                )
+            elif isinstance(va, AliasChoices):
+                local_expr: Optional[pl.Expr] = None
+                for choice in va.choices:
+                    if (part := to_expr(choice)) is not None:
+                        local_expr = (
+                            local_expr.fill_null(value=part)
+                            if local_expr is not None
+                            else part
+                        )
+                return local_expr
+            else:
+                raise NotImplementedError(
+                    f"unknown validation_alias type {field_info.validation_alias}"
+                )
+
+        for name, field_info in self.model.model_fields.items():
+            if field_info.validation_alias is None:
+                exprs.append(pl.col(name))
+            else:
+                expr = to_expr(field_info.validation_alias)
+                if name in self.columns:
+                    if expr is None:
+                        exprs.append(pl.col(name))
+                    else:
+                        exprs.append(pl.col(name).fill_null(value=expr))
+                elif expr is not None:
+                    exprs.append(expr.alias(name))
+
+        return self.select(exprs)
+
+    def cast(
+        self: LDF, strict: bool = False, columns: Optional[Sequence[str]] = None
+    ) -> LDF:
+        """Cast columns to `dtypes` specified by the associated Patito model.
+
+        Args:
+            strict: If set to ``False``, columns which are technically compliant with
+                the specified field type, will not be casted. For example, a column
+                annotated with ``int`` is technically compliant with ``pl.UInt8``, even
+                if ``pl.Int64`` is the default dtype associated with ``int``-annotated
+                fields. If ``strict`` is set to ``True``, the resulting dtypes will
+                be forced to the default dtype associated with each python type.
+            columns: Optionally, a list of column names to cast. If not provided, all
+                columns are casted.
+
+        Returns:
+            LazyFrame[Model]: A dataframe with columns casted to the correct dtypes.
+
+        Examples:
+            Create a simple model:
+
+            >>> import patito as pt
+            >>> import polars as pl
+            >>> class Product(pt.Model):
+            ...     name: str
+            ...     cent_price: int = pt.Field(dtype=pl.UInt16)
+            ...
+
+            Now we can use this model to cast some simple data:
+
+            >>> Product.LazyFrame({"name": ["apple"], "cent_price": ["8"]}).cast().collect()
+            shape: (1, 2)
+            ┌───────┬────────────┐
+            │ name  ┆ cent_price │
+            │ ---   ┆ ---        │
+            │ str   ┆ u16        │
+            ╞═══════╪════════════╡
+            │ apple ┆ 8          │
+            └───────┴────────────┘
+
+        """
+        properties = self.model._schema_properties()
+        valid_dtypes = self.model.valid_dtypes
+        default_dtypes = self.model.dtypes
+        columns = columns or self.columns
+        exprs = []
+        for column, current_dtype in zip(self.columns, self.dtypes):
+            if (column not in columns) or (column not in properties):
+                exprs.append(pl.col(column))
+            elif "dtype" in properties[column]:
+                exprs.append(pl.col(column).cast(properties[column]["dtype"]))
+            elif not strict and current_dtype in valid_dtypes[column]:
+                exprs.append(pl.col(column))
+            else:
+                exprs.append(pl.col(column).cast(default_dtypes[column]))
+        return self.with_columns(exprs)
+
+    @classmethod
+    def from_existing(cls: Type[LDF], lf: pl.LazyFrame) -> LDF:
+        """Construct a patito.DataFrame object from an existing polars.DataFrame object."""
+        return cls.model.LazyFrame._from_pyldf(lf._ldf).cast()
+
 
 class DataFrame(pl.DataFrame, Generic[ModelType]):
-    """
-    A sub-class of polars.DataFrame with additional functionality related to Model.
+    """A sub-class of polars.DataFrame with additional functionality related to Model.
 
     Two different methods are available for constructing model-aware data frames.
     Assume a simple model with two fields:
@@ -136,8 +332,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
     def _construct_dataframe_model_class(
         cls: Type[DF], model: Type[OtherModelType]
     ) -> Type[DataFrame[OtherModelType]]:
-        """
-        Return custom DataFrame sub-class where DataFrame.model is set.
+        """Return custom DataFrame sub-class where DataFrame.model is set.
 
         Can be used to construct a DataFrame class where
         DataFrame.set_model(model) is implicitly invoked at instantiation.
@@ -148,34 +343,34 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
         Returns:
             A custom DataFrame model class where DataFrame._model has been correctly
                 "hard-coded" to the given model.
+
         """
         new_class = type(
-            f"{model.schema()['title']}DataFrame",
+            f"{model.model_json_schema()['title']}DataFrame",
             (cls,),
             {"model": model},
         )
         return new_class
 
     def lazy(self: DataFrame[ModelType]) -> LazyFrame[ModelType]:
-        """
-        Convert DataFrame into LazyFrame.
+        """Convert DataFrame into LazyFrame.
 
         See documentation of polars.DataFrame.lazy() for full description.
 
         Returns:
             A new LazyFrame object.
+
         """
-        lazyframe_class: LazyFrame[
-            ModelType
-        ] = LazyFrame._construct_lazyframe_model_class(
-            model=getattr(self, "model", None)
+        lazyframe_class: LazyFrame[ModelType] = (
+            LazyFrame._construct_lazyframe_model_class(
+                model=getattr(self, "model", None)
+            )
         )  # type: ignore
         ldf = lazyframe_class._from_pyldf(super().lazy()._ldf)
         return ldf
 
     def set_model(self, model):  # type: ignore[no-untyped-def] # noqa: ANN001, ANN201
-        """
-        Associate a given patito ``Model`` with the dataframe.
+        """Associate a given patito ``Model`` with the dataframe.
 
         The model schema is used by methods that depend on a model being associated with
         the given dataframe such as :ref:`DataFrame.validate() <DataFrame.validate>`
@@ -228,6 +423,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             │ 2    ┆ B      │
             └──────┴────────┘
             >>> casted_classes.validate()
+
         """
         cls = self._construct_dataframe_model_class(model=model)
         return cast(
@@ -235,9 +431,23 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             cls._from_pydf(self._df),
         )
 
-    def cast(self: DF, strict: bool = False) -> DF:
+    def unalias(self: DF) -> DF:
+        """Un-aliases column names using information from pydantic validation_alias.
+
+        In order of preference - model field name then validation_aliases in order of occurrence
+
+        limitation - AliasChoice validation type only supports selecting a single element of an array
+
+        Returns:
+            DataFrame[Model]: A dataframe with columns normalized to model names.
+
         """
-        Cast columns to `dtypes` specified by the associated Patito model.
+        return self.lazy().unalias().collect()
+
+    def cast(
+        self: DF, strict: bool = False, columns: Optional[Sequence[str]] = None
+    ) -> DF:
+        """Cast columns to `dtypes` specified by the associated Patito model.
 
         Args:
             strict: If set to ``False``, columns which are technically compliant with
@@ -246,6 +456,8 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
                 if ``pl.Int64`` is the default dtype associated with ``int``-annotated
                 fields. If ``strict`` is set to ``True``, the resulting dtypes will
                 be forced to the default dtype associated with each python type.
+            columns: Optionally, a list of column names to cast. If not provided, all
+                columns are casted.
 
         Returns:
             DataFrame[Model]: A dataframe with columns casted to the correct dtypes.
@@ -271,29 +483,16 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             ╞═══════╪════════════╡
             │ apple ┆ 8          │
             └───────┴────────────┘
+
         """
-        properties = self.model._schema_properties()
-        valid_dtypes = self.model.valid_dtypes
-        default_dtypes = self.model.dtypes
-        columns = []
-        for column, current_dtype in zip(self.columns, self.dtypes):
-            if column not in properties:
-                columns.append(pl.col(column))
-            elif "dtype" in properties[column]:
-                columns.append(pl.col(column).cast(properties[column]["dtype"]))
-            elif not strict and current_dtype in valid_dtypes[column]:
-                columns.append(pl.col(column))
-            else:
-                columns.append(pl.col(column).cast(default_dtypes[column]))
-        return self.with_columns(columns)
+        return self.lazy().cast(strict=strict, columns=columns).collect()
 
     def drop(
         self: DF,
         columns: Optional[Union[str, Collection[str]]] = None,
         *more_columns: str,
     ) -> DF:
-        """
-        Drop one or more columns from the dataframe.
+        """Drop one or more columns from the dataframe.
 
         If ``name`` is not provided then all columns `not` specified by the associated
         patito model, for instance set with
@@ -330,9 +529,8 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
         else:
             return self.drop(list(set(self.columns) - set(self.model.columns)))
 
-    def validate(self: DF) -> DF:
-        """
-        Validate the schema and content of the dataframe.
+    def validate(self, columns: Optional[Sequence[str]] = None, **kwargs: Any):
+        """Validate the schema and content of the dataframe.
 
         You must invoke ``.set_model()`` before invoking ``.validate()`` in order
         to specify how the dataframe should be validated.
@@ -345,7 +543,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
                 validation. Note that ``patito.Model.DataFrame`` automatically invokes
                 ``DataFrame.set_model()`` for you.
 
-            patito.exceptions.ValidationError: If the dataframe does not match the
+            patito.exceptions.DataFrameValidationError: If the dataframe does not match the
                 specified schema.
 
         Examples:
@@ -366,7 +564,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             ... ).set_model(Product)
             >>> try:
             ...     df.validate()
-            ... except pt.ValidationError as exc:
+            ... except pt.DataFrameValidationError as exc:
             ...     print(exc)
             ...
             3 validation errors for Product
@@ -376,18 +574,18 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
               2 rows with duplicated values. (type=value_error.rowvalue)
             temperature_zone
               Rows with invalid values: {'oven'}. (type=value_error.rowvalue)
+
         """
         if not hasattr(self, "model"):
             raise TypeError(
                 f"You must invoke {self.__class__.__name__}.set_model() "
                 f"before invoking {self.__class__.__name__}.validate()."
             )
-        self.model.validate(dataframe=self)
+        self.model.validate(dataframe=self, columns=columns, **kwargs)
         return self
 
-    def derive(self: DF) -> DF:
-        """
-        Populate columns which have ``pt.Field(derived_from=...)`` definitions.
+    def derive(self: DF, columns: list[str] | None = None) -> DF:
+        """Populate columns which have ``pt.Field(derived_from=...)`` definitions.
 
         If a column field on the data frame model has ``patito.Field(derived_from=...)``
         specified, the given value will be used to define the column. If
@@ -411,32 +609,17 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             ...
             >>> Foo.DataFrame({"foo": [1, 2]}).derive()
             shape: (2, 3)
-            ┌─────┬─────┬────────────┐
-            │ foo ┆ bar ┆ double_bar │
-            │ --- ┆ --- ┆ ---        │
-            │ i64 ┆ i64 ┆ i64        │
-            ╞═════╪═════╪════════════╡
-            │ 1   ┆ 1   ┆ 2          │
-            │ 2   ┆ 2   ┆ 4          │
-            └─────┴─────┴────────────┘
+            ┌─────┬────────────┬─────┐
+            │ bar ┆ double_bar ┆ foo │
+            │ --- ┆ ---        ┆ --- │
+            │ i64 ┆ i64        ┆ i64 │
+            ╞═════╪════════════╪═════╡
+            │ 1   ┆ 2          ┆ 1   │
+            │ 2   ┆ 4          ┆ 2   │
+            └─────┴────────────┴─────┘
+
         """
-        df = self.lazy()
-        for column_name, props in self.model._schema_properties().items():
-            if "derived_from" in props:
-                derived_from = props["derived_from"]
-                dtype = self.model.dtypes[column_name]
-                if isinstance(derived_from, str):
-                    df = df.with_columns(
-                        pl.col(derived_from).cast(dtype).alias(column_name)
-                    )
-                elif isinstance(derived_from, pl.Expr):
-                    df = df.with_columns(derived_from.cast(dtype).alias(column_name))
-                else:
-                    raise TypeError(
-                        "Can not derive dataframe column from type "
-                        f"{type(derived_from)}."
-                    )
-        return cast(DF, df.collect())
+        return cast(DF, self.lazy().derive(columns=columns).collect())
 
     def fill_null(
         self: DF,
@@ -449,10 +632,9 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
         limit: Optional[int] = None,
         matches_supertype: bool = True,
     ) -> DF:
-        """
-        Fill null values using a filling strategy, literal, or ``Expr``.
+        """Fill null values using a filling strategy, literal, or ``Expr``.
 
-        If ``"default"`` is provided as the strategy, the model fields with default
+        If ``"defaults"`` is provided as the strategy, the model fields with default
         values are used to fill missing values.
 
         Args:
@@ -488,6 +670,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             │ apple  ┆ 10    │
             │ banana ┆ 19    │
             └────────┴───────┘
+
         """
         if strategy != "defaults":  # pragma: no cover
             return cast(  # pyright: ignore[redundant-cast]
@@ -501,14 +684,20 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             )
         return self.with_columns(
             [
-                pl.col(column).fill_null(pl.lit(default_value))
+                (
+                    pl.col(column).fill_null(
+                        pl.lit(default_value, self.model.dtypes[column])
+                    )
+                    if column in self.columns
+                    else pl.Series(column, [default_value], self.model.dtypes[column])
+                )  # NOTE: hack to get around polars bug https://github.com/pola-rs/polars/issues/13602
+                # else pl.lit(default_value, self.model.dtypes[column]).alias(column)
                 for column, default_value in self.model.defaults.items()
             ]
         ).set_model(self.model)
 
     def get(self, predicate: Optional[pl.Expr] = None) -> ModelType:
-        """
-        Fetch the single row that matches the given polars predicate.
+        """Fetch the single row that matches the given polars predicate.
 
         If you expect a data frame to already consist of one single row,
         you can use ``.get()`` without any arguments to return that row.
@@ -574,6 +763,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             ...     print(e)
             ...
             DataFrame.get() yielded 0 rows.
+
         """
         row = self if predicate is None else self.filter(predicate)
         if row.height == 0:
@@ -589,12 +779,12 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             return self._pydantic_model().from_row(row)  # type: ignore
 
     def _pydantic_model(self) -> Type[Model]:
-        """
-        Dynamically construct patito model compliant with dataframe.
+        """Dynamically construct patito model compliant with dataframe.
 
         Returns:
             A pydantic model class where all the rows have been specified as
                 `typing.Any` fields.
+
         """
         from patito.pydantic import Model
 
@@ -608,14 +798,17 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             ),
         )
 
+    def as_polars(self) -> pl.DataFrame:
+        """Convert patito dataframe to polars dataframe."""
+        return pl.DataFrame._from_pydf(self._df)
+
     @classmethod
     def read_csv(  # type: ignore[no-untyped-def]
         cls: Type[DF],
         *args,  # noqa: ANN002
         **kwargs,  # noqa: ANN003
     ) -> DF:
-        r"""
-        Read CSV and apply correct column name and types from model.
+        r"""Read CSV and apply correct column name and types from model.
 
         If any fields have ``derived_from`` specified, the given expression will be used
         to populate the given column(s).
@@ -670,10 +863,25 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             # ╞═════╪═════╡
             # │ 1.0 ┆ 1   │
             # └─────┴─────┘
+
         """
         kwargs.setdefault("dtypes", cls.model.dtypes)
-        if not kwargs.get("has_header", True) and "columns" not in kwargs:
+        has_header = kwargs.get("has_header", True)
+        if not has_header and "columns" not in kwargs:
             kwargs.setdefault("new_columns", cls.model.columns)
+        alias_gen = cls.model.model_config.get("alias_generator")
+        if alias_gen:
+            alias_func = alias_gen.validation_alias or alias_gen.alias
+        if has_header and alias_gen and alias_func:
+            fields_to_cols = {
+                field_name: alias_func(field_name)
+                for field_name in cls.model.model_fields
+            }
+            kwargs["dtypes"] = {
+                fields_to_cols.get(field, field): dtype
+                for field, dtype in kwargs["dtypes"].items()
+            }
+            # TODO: other forms of alias setting like in Field
         df = cls.model.DataFrame._from_pydf(pl.read_csv(*args, **kwargs)._df)
         return df.derive()
 
@@ -684,7 +892,7 @@ class DataFrame(pl.DataFrame, Generic[ModelType]):
             pl.Expr, str, pl.Series, list[bool], np.ndarray[Any, Any], bool
         ],
     ) -> DF:
-        return cast(DF, super().filter(predicate=predicate))
+        return cast(DF, super().filter(predicate))
 
     def select(  # noqa: D102
         self: DF,