dataframely 2.12.0__tar.gz → 2.13.1__tar.gz

{dataframely-2.12.0 → dataframely-2.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframely
-Version: 2.12.0
+Version: 2.13.1
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11

dataframely-2.13.1/dataframely/_deprecation.py

@@ -0,0 +1,58 @@
+# Copyright (c) QuantCo 2025-2026
+# SPDX-License-Identifier: BSD-3-Clause
+
+from __future__ import annotations
+
+import sys
+import warnings
+from functools import wraps
+from typing import TYPE_CHECKING, TypeVar
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+    from typing import ParamSpec
+
+    P = ParamSpec("P")
+    T = TypeVar("T")
+
+
+def issue_deprecation_warning(message: str, *, version: str = "") -> None:
+    """Issue a deprecation warning pointing at the caller of the deprecated method.
+
+    This must be called directly from the body of the deprecated (public) method so
+    that the warning points at the user's code rather than at dataframely internals.
+
+    Args:
+        message: The message associated with the warning.
+        version: The dataframely version in which the deprecation occurred (if not
+            already part of ``message``).
+    """
+    if version:
+        message = f"{message.strip()}\n(Deprecated in dataframely {version})"
+    # `stacklevel=2` blames the caller of the deprecated method (one frame up from this
+    # function). All call sites invoke this directly from the deprecated method body.
+    warnings.warn(message, DeprecationWarning, stacklevel=2)
+
+
+if sys.version_info >= (3, 13):
+    from warnings import deprecated
+else:
+    try:
+        from typing_extensions import deprecated
+    except ImportError:  # pragma: no cover
+
+        def deprecated(  # type: ignore[no-redef]
+            message: str,
+        ) -> Callable[[Callable[P, T]], Callable[P, T]]:
+            """Fallback for :func:`warnings.deprecated` without :pep:`702` support."""
+
+            def decorate(function: Callable[P, T]) -> Callable[P, T]:
+                @wraps(function)
+                def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
+                    issue_deprecation_warning(message)
+                    return function(*args, **kwargs)
+
+                wrapper.__deprecated__ = message  # type: ignore[attr-defined]
+                return wrapper
+
+            return decorate

{dataframely-2.12.0 → dataframely-2.13.1}/dataframely/collection/collection.py

@@ -28,6 +28,7 @@ import polars as pl
 import polars.exceptions as plexc
 
 from dataframely._compat import deltalake
+from dataframely._deprecation import deprecated, issue_deprecation_warning
 from dataframely._filter import Filter
 from dataframely._native import format_rule_failures
 from dataframely._plugin import all_rules_required
@@ -63,6 +64,15 @@ else:
 
 _FILTER_COLUMN_PREFIX = "__DATAFRAMELY_FILTER_COLUMN__"
 
+#: Deprecation message emitted when reading a collection with implicit validation, i.e.
+#: with any ``validation`` other than ``"skip"`` (see #367).
+_IMPLICIT_VALIDATION_DEPRECATION = (
+    "Reading a collection with `validation != 'skip'` is deprecated. Starting with "
+    "dataframely v3, data is read without inspecting schema metadata and without "
+    "running validation. Pass `validation='skip'` to opt into the future behavior, or "
+    "call `validate` explicitly if you require validation."
+)
+
 P = ParamSpec("P")
 T = TypeVar("T")
 
@@ -386,6 +396,7 @@ class Collection(BaseCollection, ABC):
         *,
         cast: bool = False,
         eager: bool = True,
+        skip_member_validation: bool = False,
         **kwargs: Any,
     ) -> Self:
         """Validate that a set of data frames satisfy the collection's invariants.
@@ -406,6 +417,11 @@ class Collection(BaseCollection, ABC):
                 :meth:`~polars.LazyFrame.collect` on the individual member or
                 :meth:`collect_all` on the collection. Note that, in the latter case,
                 information from error messages is limited.
+            skip_member_validation: Whether to skip validating individual members and only
+                apply the collection filters. **Use this option with caution** as it
+                requires the caller to ensure that the individual members have been
+                validated. This option is particularly useful in performance-critical
+                scenarios where the members are known to be valid.
             kwargs: Keyword arguments passed directly to :meth:`polars.collect_all` and
                 :meth:`polars.LazyFrame.collect` when `eager=True`.
 
@@ -429,7 +445,13 @@ class Collection(BaseCollection, ABC):
         if eager:
             # If we perform the validation eagerly, we call filter and check the failure
             # information to properly construct a useful error message.
-            filtered, failures = cls.filter(data, cast=cast, eager=True, **kwargs)
+            filtered, failures = cls.filter(
+                data,
+                cast=cast,
+                eager=True,
+                skip_member_validation=skip_member_validation,
+                **kwargs,
+            )
             if any(len(failure) > 0 for failure in failures.values()):
                 errors: dict[str, str] = {}
                 for member, failure in failures.items():
@@ -460,7 +482,17 @@ class Collection(BaseCollection, ABC):
             # efficiently as we cannot easily propagate error messages from different
             # members anyways.
             members: dict[str, pl.LazyFrame] = {
-                name: member.schema.validate(data[name].lazy(), cast=cast, eager=False)
+                name: (
+                    (
+                        member.schema.cast(data[name].lazy())
+                        if cast
+                        else data[name].lazy()
+                    )
+                    if skip_member_validation
+                    else member.schema.validate(
+                        data[name].lazy(), cast=cast, eager=False
+                    )
+                )
                 for name, member in cls.members().items()
                 if name in data
             }
@@ -556,6 +588,7 @@ class Collection(BaseCollection, ABC):
         *,
         cast: bool = False,
         eager: bool = True,
+        skip_member_validation: bool = False,
         **kwargs: Any,
     ) -> CollectionFilterResult[Self]:
         """Filter the members data frame by their schemas and the collection's filters.
@@ -572,6 +605,11 @@ class Collection(BaseCollection, ABC):
             eager: Whether the filter operation should be performed eagerly.
                 Note that until https://github.com/pola-rs/polars/pull/24129 is
                 released, eagerly filtering can provide significant speedups.
+            skip_member_validation: Whether to skip filtering individual members and only
+                apply the collection filters. **Use this option with caution** as it
+                requires the caller to ensure that the individual members have been
+                validated. This option is particularly useful in performance-critical
+                scenarios where the members are known to already be valid.
             kwargs: Keyword arguments passed directly to :meth:`polars.collect_all` and
                 :meth:`polars.LazyFrame.collect` when `eager=True`.
 
@@ -615,10 +653,20 @@ class Collection(BaseCollection, ABC):
             if member.is_optional and member_name not in data:
                 continue
 
-            member_result, failures[member_name] = member.schema.filter(
-                data[member_name].lazy(), cast=cast, eager=eager, **kwargs
-            )
-            results[member_name] = member_result.lazy()
+            if skip_member_validation:
+                results[member_name] = (
+                    member.schema.cast(data[member_name].lazy())
+                    if cast
+                    else data[member_name].lazy()
+                )
+                failures[member_name] = FailureInfo._create_empty(
+                    member.schema, with_casting_rules=cast
+                )
+            else:
+                member_result, failures[member_name] = member.schema.filter(
+                    data[member_name].lazy(), cast=cast, eager=eager, **kwargs
+                )
+                results[member_name] = member_result.lazy()
 
         # Once we've done that, we can apply the filters on this collection. To this end,
         # we iterate over all filters and store the filter results.
@@ -1023,7 +1071,16 @@ class Collection(BaseCollection, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            Reading with `validation != "skip"` is deprecated. Starting with
+            dataframely v3, this method reads the data without inspecting any schema
+            metadata and without running validation. Pass `validation="skip"` to opt
+            into this behavior, or call :meth:`validate` explicitly if you require
+            validation.
         """
+        if validation != "skip":
+            issue_deprecation_warning(_IMPLICIT_VALIDATION_DEPRECATION)
         return cls._read(
             backend=ParquetStorageBackend(),
             validation=validation,
@@ -1080,7 +1137,16 @@ class Collection(BaseCollection, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            Reading with `validation != "skip"` is deprecated. Starting with
+            dataframely v3, this method reads the data without inspecting any schema
+            metadata and without running validation. Pass `validation="skip"` to opt
+            into this behavior, or call :meth:`validate` explicitly if you require
+            validation.
         """
+        if validation != "skip":
+            issue_deprecation_warning(_IMPLICIT_VALIDATION_DEPRECATION)
         return cls._read(
             backend=ParquetStorageBackend(),
             validation=validation,
@@ -1089,6 +1155,10 @@ class Collection(BaseCollection, ABC):
             **kwargs,
         )
 
+    @deprecated(
+        "`Collection.write_delta` is deprecated and will be removed in dataframely v3. "
+        "Write the individual members with `polars.DataFrame.write_delta` instead."
+    )
     def write_delta(
         self, target: str | Path | deltalake.DeltaTable, **kwargs: Any
     ) -> None:
@@ -1115,6 +1185,10 @@ class Collection(BaseCollection, ABC):
             break your schema.
 
             This method suffers from the same limitations as :meth:`~dataframely.Schema.serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Write the
+            individual members with :meth:`polars.DataFrame.write_delta` instead.
         """
         self._write(
             backend=DeltaStorageBackend(),
@@ -1123,6 +1197,11 @@ class Collection(BaseCollection, ABC):
         )
 
     @classmethod
+    @deprecated(
+        "`Collection.scan_delta` is deprecated and will be removed in dataframely v3. "
+        "Read the individual members with `polars.scan_delta` and call `validate` "
+        "explicitly instead."
+    )
     def scan_delta(
         cls,
         source: str | Path | deltalake.DeltaTable,
@@ -1176,6 +1255,11 @@ class Collection(BaseCollection, ABC):
             break your schema.
 
             Be aware that this method suffers from the same limitations as :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Read the
+            individual members with :meth:`polars.scan_delta` and call :meth:`validate`
+            explicitly instead.
         """
         return cls._read(
             backend=DeltaStorageBackend(),
@@ -1185,6 +1269,11 @@ class Collection(BaseCollection, ABC):
         )
 
     @classmethod
+    @deprecated(
+        "`Collection.read_delta` is deprecated and will be removed in dataframely v3. "
+        "Read the individual members with `polars.read_delta` and call `validate` "
+        "explicitly instead."
+    )
     def read_delta(
         cls,
         source: str | Path | deltalake.DeltaTable,
@@ -1237,6 +1326,11 @@ class Collection(BaseCollection, ABC):
             break your schema.
 
             Be aware that this method suffers from the same limitations as :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Read the
+            individual members with :meth:`polars.read_delta` and call :meth:`validate`
+            explicitly instead.
         """
         return cls._read(
             backend=DeltaStorageBackend(),

{dataframely-2.12.0 → dataframely-2.13.1}/dataframely/filter_result.py

@@ -106,6 +106,17 @@ class FailureInfo(Generic[S]):
         self._rule_columns = rule_columns
         self.schema = schema
 
+    @classmethod
+    def _create_empty(cls, schema: type[S], with_casting_rules: bool) -> FailureInfo[S]:
+        rules = schema._validation_rules(with_cast=with_casting_rules)
+        lf = pl.LazyFrame(
+            schema={
+                **schema.to_polars_schema(),  # type: ignore
+                **{rule: pl.Boolean for rule in rules},
+            }
+        )
+        return cls(lf=lf, rule_columns=list(rules.keys()), schema=schema)
+
     @cached_property
     def _df(self) -> pl.DataFrame:
         return self._lf.collect()

{dataframely-2.12.0 → dataframely-2.13.1}/dataframely/schema.py

@@ -18,6 +18,7 @@ from polars._typing import FileSource
 
 from ._base_schema import ORIGINAL_COLUMN_PREFIX, BaseSchema
 from ._compat import PartitionSchemeOrSinkDirectory, deltalake, pa, pydantic, sa
+from ._deprecation import deprecated
 from ._match_to_schema import match_to_schema
 from ._native import format_rule_failures
 from ._plugin import all_rules, all_rules_horizontal, all_rules_required
@@ -897,6 +898,10 @@ class Schema(BaseSchema, ABC):
     # ------------------------------------ PARQUET ----------------------------------- #
 
     @classmethod
+    @deprecated(
+        "`Schema.write_parquet` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.DataFrame.write_parquet` directly instead."
+    )
     def write_parquet(
         cls, df: DataFrame[Self], /, file: str | Path | IO[bytes], **kwargs: Any
     ) -> None:
@@ -919,10 +924,18 @@ class Schema(BaseSchema, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.DataFrame.write_parquet` directly instead.
         """
         cls._write(df=df, backend=ParquetStorageBackend(), file=file, **kwargs)
 
     @classmethod
+    @deprecated(
+        "`Schema.sink_parquet` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.LazyFrame.sink_parquet` directly instead."
+    )
     def sink_parquet(
         cls,
         lf: LazyFrame[Self],
@@ -947,10 +960,18 @@ class Schema(BaseSchema, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.LazyFrame.sink_parquet` directly instead.
         """
         cls._sink(lf=lf, backend=ParquetStorageBackend(), file=file, **kwargs)
 
     @classmethod
+    @deprecated(
+        "`Schema.read_parquet` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.read_parquet` and call `validate` explicitly instead."
+    )
     def read_parquet(
         cls,
         source: FileSource,
@@ -997,6 +1018,10 @@ class Schema(BaseSchema, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.read_parquet` and call :meth:`validate` explicitly instead.
         """
         return cls._read(
             ParquetStorageBackend(),
@@ -1007,6 +1032,10 @@ class Schema(BaseSchema, ABC):
         )
 
     @classmethod
+    @deprecated(
+        "`Schema.scan_parquet` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.scan_parquet` and call `validate` explicitly instead."
+    )
     def scan_parquet(
         cls,
         source: FileSource,
@@ -1053,6 +1082,10 @@ class Schema(BaseSchema, ABC):
         Attention:
             Be aware that this method suffers from the same limitations as
             :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.scan_parquet` and call :meth:`validate` explicitly instead.
         """
         return cls._read(
             ParquetStorageBackend(),
@@ -1099,6 +1132,10 @@ class Schema(BaseSchema, ABC):
 
     # --------------------------------- Delta -----------------------------------------#
     @classmethod
+    @deprecated(
+        "`Schema.write_delta` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.DataFrame.write_delta` directly instead."
+    )
     def write_delta(
         cls,
         df: DataFrame[Self],
@@ -1127,6 +1164,10 @@ class Schema(BaseSchema, ABC):
             in violation of group constraints that dataframely cannot catch
             without re-validating. Only use appends if you are certain that they do not
             break your schema.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.DataFrame.write_delta` directly instead.
         """
         DeltaStorageBackend().write_frame(
             df=df,
@@ -1135,6 +1176,10 @@ class Schema(BaseSchema, ABC):
         )
 
     @classmethod
+    @deprecated(
+        "`Schema.scan_delta` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.scan_delta` and call `validate` explicitly instead."
+    )
     def scan_delta(
         cls,
         source: str | Path | deltalake.DeltaTable,
@@ -1182,6 +1227,10 @@ class Schema(BaseSchema, ABC):
             that are not through dataframely will result in losing the metadata.
 
             This method suffers from the same limitations as :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.scan_delta` and call :meth:`validate` explicitly instead.
         """
         return cls._read(
             DeltaStorageBackend(),
@@ -1192,6 +1241,10 @@ class Schema(BaseSchema, ABC):
         )
 
     @classmethod
+    @deprecated(
+        "`Schema.read_delta` is deprecated and will be removed in dataframely v3. "
+        "Use `polars.read_delta` and call `validate` explicitly instead."
+    )
     def read_delta(
         cls,
         source: str | Path | deltalake.DeltaTable,
@@ -1244,6 +1297,10 @@ class Schema(BaseSchema, ABC):
             break your schema.
 
             This method suffers from the same limitations as :meth:`serialize`.
+
+        .. deprecated:: 3.0.0
+            This method is deprecated and will be removed in dataframely v3. Use
+            :meth:`polars.read_delta` and call :meth:`validate` explicitly instead.
         """
         return cls._read(
             DeltaStorageBackend(),

{dataframely-2.12.0 → dataframely-2.13.1}/docs/guides/features/serialization.md

@@ -1,5 +1,27 @@
 # Serialization
 
+```{warning}
+Most of the I/O functionality described on this page is **deprecated** and will be
+removed in dataframely v3 (see [#367](https://github.com/Quantco/dataframely/issues/367)).
+Calling any of these methods now emits a {class}`DeprecationWarning`. Specifically:
+
+- All I/O methods on {class}`~dataframely.Schema`
+  ({meth}`~dataframely.Schema.write_parquet`, {meth}`~dataframely.Schema.sink_parquet`,
+  {meth}`~dataframely.Schema.read_parquet`, {meth}`~dataframely.Schema.scan_parquet`,
+  {meth}`~dataframely.Schema.write_delta`, {meth}`~dataframely.Schema.read_delta`,
+  {meth}`~dataframely.Schema.scan_delta`) are deprecated. Use the corresponding
+  `polars` functions directly and call {meth}`~dataframely.Schema.validate` explicitly
+  where validation is required.
+- The `deltalake` I/O methods on {class}`~dataframely.Collection`
+  ({meth}`~dataframely.Collection.write_delta`, {meth}`~dataframely.Collection.read_delta`,
+  {meth}`~dataframely.Collection.scan_delta`) are deprecated.
+- {meth}`~dataframely.Collection.read_parquet` and
+  {meth}`~dataframely.Collection.scan_parquet` continue to exist, but reading with
+  `validation != "skip"` is deprecated: metadata will no longer be inspected and
+  validation will no longer run implicitly. Pass `validation="skip"` to opt into the
+  future behavior, or call {meth}`~dataframely.Collection.validate` explicitly.
+```
+
 `dataframely` provides support for easily storing and reading validated data.
 `polars` already provides native support for serializing data frames into different storage
 backends. For the storage of the data itself, `dataframely` usually dispatches to polars-native

{dataframely-2.12.0 → dataframely-2.13.1}/docs/guides/migration/index.md

@@ -26,17 +26,16 @@ As always, automated testing is useful here, but we also recommend checking the
 [published on GitHub](https://github.com/Quantco/dataframely/releases).
 
 In order to give users a heads-up before breaking changes are released, we introduce
-[FutureWarnings](https://docs.python.org/3/library/exceptions.html#FutureWarning).
+[DeprecationWarnings](https://docs.python.org/3/library/exceptions.html#DeprecationWarning).
 Warnings are the most direct and effective tool at our disposal for reaching users directly.
 We therefore generally recommend that users do not silence such warnings explicitly, but instead migrate their code
 proactively, whenever possible.
 However, we also understand that the need for migration may catch users at an inconvenient time, and a temporary band
 aid solution might be required.
-Users can disable `FutureWarnings` either through
-[python builtins](https://docs.python.org/3/library/warnings.html#warnings.filterwarnings),
-builtins from tools
-like [pytest](https://docs.pytest.org/en/stable/how-to/capture-warnings.html#controlling-warnings),
-or by setting the `DATAFRAMELY_NO_FUTURE_WARNINGS` environment variable to `true` or `1`.
+Users can disable `DeprecationWarnings` either through
+[python builtins](https://docs.python.org/3/library/warnings.html#warnings.filterwarnings)
+or through builtins from tools
+like [pytest](https://docs.pytest.org/en/stable/how-to/capture-warnings.html#controlling-warnings).
 
 ## Experimental features
 

{dataframely-2.12.0 → dataframely-2.13.1}/pyproject.toml

@@ -27,7 +27,7 @@ description = "A declarative, polars-native data frame validation library"
 name = "dataframely"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "2.12.0"
+version = "2.13.1"
 
 [project.optional-dependencies]
 deltalake = ["deltalake"]
@@ -107,10 +107,13 @@ addopts = "--import-mode=importlib --benchmark-skip -m 'not s3'"
 filterwarnings = [
   # By default, all warnings should yield errors
   "error",
-  # Almost all tests are oblivious to the value of `nullable`. Let's ignore the warning as long as it exists.
-  "ignore:The 'nullable' argument was not explicitly set:FutureWarning",
   # boto3 still uses .utcnow()
   "ignore::DeprecationWarning:botocore.*:",
+  # I/O deprecation warnings (see #367) are asserted in dedicated tests via
+  # `pytest.warns`; silence them elsewhere so existing tests keep exercising the
+  # still-present functionality.
+  "ignore:.*Reading a collection with .validation.*:DeprecationWarning",
+  "ignore:.*deprecated and will be removed in dataframely v3.*:DeprecationWarning",
 ]
 markers = [
   "s3: tests that run against and S3 backend",

dataframely-2.13.1/tests/collection/test_skip_member_validation.py

@@ -0,0 +1,108 @@
+# Copyright (c) QuantCo 2025-2026
+# SPDX-License-Identifier: BSD-3-Clause
+
+import polars as pl
+import polars.exceptions as plexc
+import pytest
+
+import dataframely as dy
+
+
+class FirstSchema(dy.Schema):
+    a = dy.Float64(min=5)
+
+
+class SecondSchema(dy.Schema):
+    a = dy.String()
+
+
+class Collection(dy.Collection):
+    first: dy.LazyFrame[FirstSchema]
+    second: dy.LazyFrame[SecondSchema]
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pl.LazyFrame])
+def test_validate_skip_member_validation_eager(
+    df_type: type[pl.DataFrame] | type[pl.LazyFrame],
+) -> None:
+    first = df_type({"a": [3, 4, 5]})  # NOTE: first two rows are violations
+    second = df_type({"a": ["1", "2", "3"]})
+
+    with pytest.raises(dy.exc.ValidationError):
+        Collection.validate({"first": first, "second": second}, cast=True)  # type: ignore
+
+    Collection.validate(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+        skip_member_validation=True,
+    )
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pl.LazyFrame])
+def test_validate_skip_member_validation_lazy(
+    df_type: type[pl.DataFrame] | type[pl.LazyFrame],
+) -> None:
+    first = df_type({"a": [3, 4, 5]})  # NOTE: first two rows are violations
+    second = df_type({"a": ["1", "2", "3"]})
+
+    with pytest.raises(plexc.ComputeError):
+        Collection.validate(
+            {"first": first, "second": second},  # type: ignore
+            cast=True,
+            eager=False,
+        ).collect_all()
+
+    Collection.validate(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+        skip_member_validation=True,
+        eager=False,
+    ).collect_all()
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pl.LazyFrame])
+def test_filter_skip_member_validation_eager(
+    df_type: type[pl.DataFrame] | type[pl.LazyFrame],
+) -> None:
+    first = df_type({"a": [3, 4, 5]})  # NOTE: first two rows are violations
+    second = df_type({"a": ["1", "2", "3"]})
+
+    _, failure_info = Collection.filter(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+    )
+    assert failure_info["first"].counts() == {"a|min": 2}
+    assert failure_info["second"].counts() == {}
+
+    _, failure_info = Collection.filter(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+        skip_member_validation=True,
+    )
+    assert failure_info["first"].counts() == {}
+    assert failure_info["second"].counts() == {}
+
+
+@pytest.mark.parametrize("df_type", [pl.DataFrame, pl.LazyFrame])
+def test_filter_skip_member_validation_lazy(
+    df_type: type[pl.DataFrame] | type[pl.LazyFrame],
+) -> None:
+    first = df_type({"a": [3, 4, 5]})  # NOTE: first two rows are violations
+    second = df_type({"a": ["1", "2", "3"]})
+
+    _, failure_info = Collection.filter(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+        eager=False,
+    )
+    assert failure_info["first"].counts() == {"a|min": 2}
+    assert failure_info["second"].counts() == {}
+
+    _, failure_info = Collection.filter(
+        {"first": first, "second": second},  # type: ignore
+        cast=True,
+        skip_member_validation=True,
+        eager=False,
+    )
+    assert failure_info["first"].counts() == {}
+    assert failure_info["second"].counts() == {}