dataframely 1.2.0__tar.gz → 1.3.0__tar.gz

{dataframely-1.2.0 → dataframely-1.3.0}/.copier-answers.yml

@@ -1,7 +1,7 @@
 # This file is managed by Copier; DO NOT EDIT OR REMOVE.
 _commit: v0.3.0
 _src_path: https://github.com/quantco/copier-template-python-open-source
-add_autobump_workflow: true
+add_autobump_workflow: false
 author_email: oliver.borchert@quantco.com
 author_name: Oliver Borchert
 github_url: https://github.com/quantco/dataframely

{dataframely-1.2.0 → dataframely-1.3.0}/.github/workflows/build.yml

@@ -78,7 +78,7 @@ jobs:
       id-token: write
     environment: pypi
     steps:
-      - uses: actions/download-artifact@95815c38cf2ff2164869cbab79da8d1f422bc89e # v4.2.1
+      - uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4.3.0
         with:
           path: dist
           merge-multiple: true

{dataframely-1.2.0 → dataframely-1.3.0}/Cargo.toml

@@ -12,3 +12,7 @@ pyo3 = { version = "0.24", features = ["abi3-py311", "extension-module"] }
 rand = { version = "0.9", features = ["std_rng"] }
 regex-syntax = "0.8"
 thiserror = "2.0"
+
+[profile.release]
+codegen-units = 1
+lto = true

{dataframely-1.2.0 → dataframely-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataframely
-Version: 1.2.0
+Version: 1.3.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/__init__.py

@@ -18,6 +18,7 @@ from ._typing import DataFrame, LazyFrame
 from .collection import Collection
 from .columns import (
     Any,
+    Array,
     Bool,
     Column,
     Date,
@@ -90,5 +91,6 @@ __all__ = [
     "String",
     "Struct",
     "List",
+    "Array",
     "Object",
 ]

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/_base_schema.py

@@ -98,7 +98,7 @@ class SchemaMeta(ABCMeta):
             )
 
         # 2) Check that the columns referenced in the group rules exist.
-        for name, rule in result.rules.items():
+        for rule_name, rule in result.rules.items():
             if isinstance(rule, GroupRule):
                 missing_columns = set(rule.group_columns) - set(result.columns)
                 if len(missing_columns) > 0:
@@ -106,7 +106,7 @@ class SchemaMeta(ABCMeta):
                         sorted(f"'{col}'" for col in missing_columns)
                     )
                     raise ImplementationError(
-                        f"Group validation rule '{name}' has been implemented "
+                        f"Group validation rule '{rule_name}' has been implemented "
                         f"incorrectly. It references {len(missing_columns)} columns "
                         f"which are not in the schema: {missing_list}."
                     )
@@ -116,16 +116,16 @@ class SchemaMeta(ABCMeta):
         # empty data frame and checking for the evaluated dtypes.
         if len(result.rules) > 0:
             lf_empty = pl.LazyFrame(
-                schema={name: col.dtype for name, col in result.columns.items()}
+                schema={col_name: col.dtype for col_name, col in result.columns.items()}
             )
             # NOTE: For some reason, `polars` does not yield correct dtypes when calling
             #  `collect_schema()`
             schema = with_evaluation_rules(lf_empty, result.rules).collect().schema
-            for name, rule in result.rules.items():
-                dtype = schema[name]
+            for rule_name, rule in result.rules.items():
+                dtype = schema[rule_name]
                 if not isinstance(dtype, pl.Boolean):
                     raise RuleImplementationError(
-                        name, dtype, isinstance(rule, GroupRule)
+                        rule_name, dtype, isinstance(rule, GroupRule)
                     )
 
         return super().__new__(mcs, name, bases, namespace, *args, **kwargs)

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/_rule.py

@@ -126,5 +126,7 @@ def _with_group_rules(lf: pl.LazyFrame, rules: dict[str, GroupRule]) -> pl.LazyF
     #    preserves the order of the left data frame.
     result = lf
     for group_columns, frame in group_evaluations.items():
-        result = result.join(frame, on=list(group_columns), how="left")
+        result = result.join(
+            frame, on=list(group_columns), how="left", nulls_equal=True
+        )
     return result

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/columns/__init__.py

@@ -3,6 +3,7 @@
 
 from ._base import Column
 from .any import Any
+from .array import Array
 from .bool import Bool
 from .datetime import Date, Datetime, Duration, Time
 from .decimal import Decimal
@@ -17,6 +18,7 @@ from .struct import Struct
 __all__ = [
     "Column",
     "Any",
+    "Array",
     "Bool",
     "Date",
     "Datetime",

dataframely-1.3.0/dataframely/columns/array.py

@@ -0,0 +1,105 @@
+# Copyright (c) QuantCo 2025-2025
+# SPDX-License-Identifier: BSD-3-Clause
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable, Sequence
+from typing import Any, Literal
+
+import polars as pl
+
+from dataframely._compat import pa, sa, sa_TypeEngine
+from dataframely.random import Generator
+
+from ._base import Column
+from .struct import Struct
+
+
+class Array(Column):
+    """A fixed-shape array column."""
+
+    def __init__(
+        self,
+        inner: Column,
+        shape: int | tuple[int, ...],
+        *,
+        nullable: bool = True,
+        # polars doesn't yet support grouping by arrays,
+        # see https://github.com/pola-rs/polars/issues/22574
+        primary_key: Literal[False] = False,
+        check: Callable[[pl.Expr], pl.Expr] | None = None,
+        alias: str | None = None,
+        metadata: dict[str, Any] | None = None,
+    ):
+        """
+        Args:
+            inner: The inner column type. No validation rules on the inner type are supported yet.
+            shape: The shape of the array.
+            nullable: Whether this column may contain null values.
+            primary_key: Whether this column is part of the primary key of the schema.
+                Not yet supported for the Array type.
+            check: A custom check to run for this column. Must return a non-aggregated
+                boolean expression.
+            alias: An overwrite for this column's name which allows for using a column
+                name that is not a valid Python identifier. Especially note that setting
+                this option does _not_ allow to refer to the column with two different
+                names, the specified alias is the only valid name.
+            metadata: A dictionary of metadata to attach to the column.
+        """
+        if inner.primary_key or (
+            isinstance(inner, Struct)
+            and any(col.primary_key for col in inner.inner.values())
+        ):
+            raise ValueError(
+                "`primary_key=True` is not yet supported for inner types of the Array type."
+            )
+
+        # We disallow validation rules on the inner type since Polars arrays currently don't support .eval(). Converting
+        # to a list and calling .list.eval() is possible, however, since the shape can have multiple axes, the recursive
+        # conversion could have significant performance impact. Hence, we simply disallow inner validation rules.
+        # Another option would be to allow validation rules only for sampling, but not enforce them.
+        if inner.validation_rules(pl.lit(None)):
+            raise ValueError(
+                "Validation rules on the inner type of Array are not yet supported."
+            )
+
+        super().__init__(
+            nullable=nullable,
+            primary_key=False,
+            check=check,
+            alias=alias,
+            metadata=metadata,
+        )
+        self.inner = inner
+        self.shape = shape if isinstance(shape, tuple) else (shape,)
+
+    @property
+    def dtype(self) -> pl.DataType:
+        return pl.Array(self.inner.dtype, self.shape)
+
+    def sqlalchemy_dtype(self, dialect: sa.Dialect) -> sa_TypeEngine:
+        # NOTE: We might want to add support for PostgreSQL's ARRAY type or use JSON in the future.
+        raise NotImplementedError("SQL column cannot have 'Array' type.")
+
+    def _pyarrow_dtype_of_shape(self, shape: Sequence[int]) -> pa.DataType:
+        if shape:
+            size, *rest = shape
+            return pa.list_(self._pyarrow_dtype_of_shape(rest), size)
+        else:
+            return self.inner.pyarrow_dtype
+
+    @property
+    def pyarrow_dtype(self) -> pa.DataType:
+        return self._pyarrow_dtype_of_shape(self.shape)
+
+    def _sample_unchecked(self, generator: Generator, n: int) -> pl.Series:
+        # Sample the inner elements in a flat series
+        n_elements = n * math.prod(self.shape)
+        all_elements = self.inner.sample(generator, n_elements)
+
+        # Finally, apply a null mask
+        return generator._apply_null_mask(
+            all_elements.reshape((n, *self.shape)),
+            null_probability=self._null_probability,
+        )

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/columns/enum.py

@@ -49,7 +49,7 @@ class Enum(Column):
             alias=alias,
             metadata=metadata,
         )
-        self.categories = categories
+        self.categories = list(categories)
 
     @property
     def dtype(self) -> pl.DataType:

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/columns/list.py

@@ -147,4 +147,7 @@ class List(Column):
                 chain([0], element_lengths.cum_sum()), element_lengths
             )
         ]
-        return pl.Series(list_elements)
+        # Finally, apply a null mask
+        return generator._apply_null_mask(
+            pl.Series(list_elements), null_probability=self._null_probability
+        )

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/columns/struct.py

@@ -96,10 +96,14 @@ class Struct(Column):
         return pa.struct({name: col.pyarrow_dtype for name, col in self.inner.items()})
 
     def _sample_unchecked(self, generator: Generator, n: int) -> pl.Series:
-        return (
+        series = (
             pl.DataFrame(
                 {name: col.sample(generator, n) for name, col in self.inner.items()}
             )
             .select(pl.struct(pl.all()))
             .to_series()
         )
+        # Apply a null mask.
+        return generator._apply_null_mask(
+            series, null_probability=self._null_probability
+        )

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/mypy.py

@@ -16,6 +16,7 @@ from mypy.nodes import (
     MemberExpr,
     NameExpr,
     StrExpr,
+    TupleExpr,
     TypeInfo,
     Var,
 )
@@ -189,7 +190,28 @@ def _convert_dy_column_to_dtype(
                 ],
             )
         return api.named_type("builtins.list")
-    if column_type == "Any":
+    if column_type == "Array":
+        if isinstance(column_args[0], CallExpr) and isinstance(
+            column_args[0].callee, MemberExpr | NameExpr
+        ):
+            inner_type = _convert_dy_column_to_dtype(
+                api,
+                column_args[0].callee.name,
+                column_args[0].args,
+            )
+            # If the array has more than one dimension, return a list of lists of the inner type.
+            if len(column_args) > 1 and isinstance(column_args[1], TupleExpr):
+                for _ in range(len(column_args[1].items) - 1):
+                    inner_type = api.named_type(
+                        "builtins.list",
+                        [inner_type],
+                    )
+            return api.named_type(
+                "builtins.list",
+                [inner_type],
+            )
+        return api.named_type("builtins.list")
+    if column_type == "Any" or column_type == "Object":
         return AnyType(TypeOfAny.explicit)
     # If we can't infer the type, we default to `Any`.
     # This is, for example, the case for self-defined types, e.g., via `functools.partial`.

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/random.py

@@ -392,8 +392,10 @@ class Generator:
     def _apply_null_mask(self, series: pl.Series, null_probability: float) -> pl.Series:
         if null_probability == 0:
             return series
-        null_mask = self.numpy_generator.random(series.len()) < null_probability
-        return series.scatter(np.where(null_mask)[0], None)
+        null_mask = (
+            pl.Series(self.numpy_generator.random(series.len())) > null_probability
+        )
+        return pl.select(pl.when(null_mask).then(series)).to_series()
 
 
 # --------------------------------------- UTILS -------------------------------------- #

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/testing/__init__.py

@@ -6,6 +6,7 @@ from .const import (
     COLUMN_TYPES,
     FLOAT_COLUMN_TYPES,
     INTEGER_COLUMN_TYPES,
+    NO_VALIDATION_COLUMN_TYPES,
     SUPERTYPE_COLUMN_TYPES,
 )
 from .factory import create_collection, create_collection_raw, create_schema
@@ -18,6 +19,7 @@ __all__ = [
     "FLOAT_COLUMN_TYPES",
     "INTEGER_COLUMN_TYPES",
     "SUPERTYPE_COLUMN_TYPES",
+    "NO_VALIDATION_COLUMN_TYPES",
     "create_collection",
     "create_collection_raw",
     "create_schema",

{dataframely-1.2.0 → dataframely-1.3.0}/dataframely/testing/const.py

@@ -47,3 +47,8 @@ SUPERTYPE_COLUMN_TYPES: list[type[dc.Column]] = [
 ALL_COLUMN_TYPES: list[type[dc.Column]] = (
     [dc.Any] + COLUMN_TYPES + SUPERTYPE_COLUMN_TYPES
 )
+
+# The following is a list of column types that, when created with default parameter values, add no validation rules.
+NO_VALIDATION_COLUMN_TYPES: list[type[dc.Column]] = [
+    t for t in ALL_COLUMN_TYPES if t not in FLOAT_COLUMN_TYPES
+]

{dataframely-1.2.0 → dataframely-1.3.0}/pyproject.toml

@@ -19,7 +19,7 @@ description = "A declarative, polars-native data frame validation library"
 name = "dataframely"
 readme = "README.md"
 requires-python = ">=3.11"
-version = "1.2.0"
+version = "1.3.0"
 
 [project.urls]
 Repository = "https://github.com/quantco/dataframely"

dataframely-1.3.0/tests/column_types/test_array.py

@@ -0,0 +1,159 @@
+# Copyright (c) QuantCo 2025-2025
+# SPDX-License-Identifier: BSD-3-Clause
+
+import polars as pl
+import pytest
+
+import dataframely as dy
+from dataframely.columns._base import Column
+from dataframely.testing import create_schema
+
+
+@pytest.mark.parametrize(
+    "inner",
+    [
+        (dy.Int64()),
+        (dy.Integer()),
+    ],
+)
+def test_integer_array(inner: Column) -> None:
+    schema = create_schema("test", {"a": dy.Array(inner, 1)})
+    assert schema.is_valid(
+        pl.DataFrame(
+            {"a": [[1], [2], [3]]},
+            schema={
+                "a": pl.Array(pl.Int64, 1),
+            },
+        )
+    )
+
+
+def test_invalid_inner_type() -> None:
+    schema = create_schema("test", {"a": dy.Array(dy.Int64(), 1)})
+    assert not schema.is_valid(pl.DataFrame({"a": [["1"], ["2"], ["3"]]}))
+
+
+def test_invalid_shape() -> None:
+    schema = create_schema("test", {"a": dy.Array(dy.Int64(), 2)})
+    assert not schema.is_valid(
+        pl.DataFrame(
+            {"a": [[1], [2], [3]]},
+            schema={
+                "a": pl.Array(pl.Int64, 1),
+            },
+        )
+    )
+
+
+@pytest.mark.parametrize(
+    ("column", "dtype", "is_valid"),
+    [
+        (
+            dy.Array(dy.Int64(), 1),
+            pl.Array(pl.Int64(), 1),
+            True,
+        ),
+        (
+            dy.Array(dy.String(), 1),
+            pl.Array(pl.Int64(), 1),
+            False,
+        ),
+        (
+            dy.Array(dy.String(), 1),
+            pl.Array(pl.Int64(), 2),
+            False,
+        ),
+        (
+            dy.Array(dy.Int64(), (1,)),
+            pl.Array(pl.Int64(), (1,)),
+            True,
+        ),
+        (
+            dy.Array(dy.Int64(), (1,)),
+            pl.Array(pl.Int64(), (2,)),
+            False,
+        ),
+        (
+            dy.Array(dy.String(), 1),
+            dy.Array(dy.String(), 1),
+            False,
+        ),
+        (
+            dy.Array(dy.String(), 1),
+            dy.String(),
+            False,
+        ),
+        (
+            dy.Array(dy.String(), 1),
+            pl.String(),
+            False,
+        ),
+        (
+            dy.Array(dy.Array(dy.String(), 1), 1),
+            pl.Array(pl.String(), (1, 1)),
+            True,
+        ),
+        (
+            dy.Array(dy.String(), (1, 1)),
+            pl.Array(pl.Array(pl.String(), 1), 1),
+            True,
+        ),
+    ],
+)
+def test_validate_dtype(column: Column, dtype: pl.DataType, is_valid: bool) -> None:
+    assert column.validate_dtype(dtype) == is_valid
+
+
+def test_nested_arrays() -> None:
+    schema = create_schema("test", {"a": dy.Array(dy.Array(dy.Int64(), 1), 1)})
+    assert schema.is_valid(
+        pl.DataFrame(
+            {"a": [[[1]], [[2]], [[3]]]},
+            schema={
+                "a": pl.Array(pl.Int64, (1, 1)),
+            },
+        )
+    )
+
+
+def test_nested_array() -> None:
+    schema = create_schema("test", {"a": dy.Array(dy.Array(dy.Int64(), 1), 1)})
+    assert schema.is_valid(
+        pl.DataFrame(
+            {"a": [[[1]], [[2]], [[3]]]},
+            schema={
+                "a": pl.Array(pl.Int64, (1, 1)),
+            },
+        )
+    )
+
+
+def test_array_with_inner_pk() -> None:
+    with pytest.raises(ValueError):
+        column = dy.Array(dy.String(primary_key=True), 2)
+        create_schema(
+            "test",
+            {"a": column},
+        )
+
+
+def test_array_with_rules() -> None:
+    with pytest.raises(ValueError):
+        create_schema(
+            "test", {"a": dy.Array(dy.String(min_length=2, nullable=False), 1)}
+        )
+
+
+def test_outer_nullability() -> None:
+    schema = create_schema(
+        "test",
+        {
+            "nullable": dy.Array(
+                inner=dy.Integer(),
+                shape=1,
+                nullable=True,
+            )
+        },
+    )
+    df = pl.DataFrame({"nullable": [None, None]})
+    schema.validate(df, cast=True)

{dataframely-1.2.0 → dataframely-1.3.0}/tests/column_types/test_enum.py

@@ -52,3 +52,12 @@ def test_valid_cast(
     schema = create_schema("test", {"a": enum})
     df = df_type(data)
     assert schema.is_valid(df, cast=True) == valid
+
+
+@pytest.mark.parametrize("type1", [list, tuple])
+@pytest.mark.parametrize("type2", [list, tuple])
+def test_different_sequences(type1: type, type2: type) -> None:
+    allowed = ["a", "b"]
+    S = create_schema("test", {"x": dy.Enum(type1(allowed))})
+    df = pl.DataFrame({"x": pl.Series(["a", "b"], dtype=pl.Enum(type2(allowed)))})
+    S.validate(df)

{dataframely-1.2.0 → dataframely-1.3.0}/tests/columns/test_default_dtypes.py

@@ -36,6 +36,7 @@ from dataframely.testing import create_schema
         (dy.UInt64(), pl.UInt64()),
         (dy.String(), pl.String()),
         (dy.List(dy.String()), pl.List(pl.String())),
+        (dy.Array(dy.String(), 1), pl.Array(pl.String(), 1)),
         (dy.Struct({"a": dy.String()}), pl.Struct({"a": pl.String()})),
         (dy.Enum(["a", "b"]), pl.Enum(["a", "b"])),
     ],

{dataframely-1.2.0 → dataframely-1.3.0}/tests/columns/test_pyarrow.py

@@ -8,6 +8,7 @@ from dataframely.columns import Column
 from dataframely.testing import (
     ALL_COLUMN_TYPES,
     COLUMN_TYPES,
+    NO_VALIDATION_COLUMN_TYPES,
     SUPERTYPE_COLUMN_TYPES,
     create_schema,
 )
@@ -32,6 +33,7 @@ def test_equal_polars_schema_enum() -> None:
     "inner",
     [c() for c in ALL_COLUMN_TYPES]
     + [dy.List(t()) for t in ALL_COLUMN_TYPES]
+    + [dy.Array(t(), 1) for t in NO_VALIDATION_COLUMN_TYPES]
     + [dy.Struct({"a": t()}) for t in ALL_COLUMN_TYPES],
 )
 def test_equal_polars_schema_list(inner: Column) -> None:
@@ -41,10 +43,33 @@ def test_equal_polars_schema_list(inner: Column) -> None:
     assert actual == expected
 
 
+@pytest.mark.parametrize(
+    "inner",
+    [c() for c in NO_VALIDATION_COLUMN_TYPES]
+    + [dy.List(t()) for t in NO_VALIDATION_COLUMN_TYPES]
+    + [dy.Array(t(), 1) for t in NO_VALIDATION_COLUMN_TYPES]
+    + [dy.Struct({"a": t()}) for t in NO_VALIDATION_COLUMN_TYPES],
+)
+@pytest.mark.parametrize(
+    "shape",
+    [
+        1,
+        0,
+        (0, 0),
+    ],
+)
+def test_equal_polars_schema_array(inner: Column, shape: int | tuple[int, ...]) -> None:
+    schema = create_schema("test", {"a": dy.Array(inner, shape)})
+    actual = schema.pyarrow_schema()
+    expected = schema.create_empty().to_arrow().schema
+    assert actual == expected
+
+
 @pytest.mark.parametrize(
     "inner",
     [c() for c in ALL_COLUMN_TYPES]
     + [dy.Struct({"a": t()}) for t in ALL_COLUMN_TYPES]
+    + [dy.Array(t(), 1) for t in NO_VALIDATION_COLUMN_TYPES]
     + [dy.List(t()) for t in ALL_COLUMN_TYPES],
 )
 def test_equal_polars_schema_struct(inner: Column) -> None:
@@ -71,6 +96,7 @@ def test_nullability_information_enum(nullable: bool) -> None:
     "inner",
     [c() for c in ALL_COLUMN_TYPES]
     + [dy.List(t()) for t in ALL_COLUMN_TYPES]
+    + [dy.Array(t(), 1) for t in NO_VALIDATION_COLUMN_TYPES]
     + [dy.Struct({"a": t()}) for t in ALL_COLUMN_TYPES],
 )
 @pytest.mark.parametrize("nullable", [True, False])
@@ -83,6 +109,7 @@ def test_nullability_information_list(inner: Column, nullable: bool) -> None:
     "inner",
     [c() for c in ALL_COLUMN_TYPES]
     + [dy.Struct({"a": t()}) for t in ALL_COLUMN_TYPES]
+    + [dy.Array(t(), 1) for t in NO_VALIDATION_COLUMN_TYPES]
     + [dy.List(t()) for t in ALL_COLUMN_TYPES],
 )
 @pytest.mark.parametrize("nullable", [True, False])

{dataframely-1.2.0 → dataframely-1.3.0}/tests/columns/test_sample.py

@@ -178,12 +178,20 @@ def test_sample_enum(generator: Generator) -> None:
 def test_sample_list(generator: Generator) -> None:
     column = dy.List(dy.String(regex="[abc]"), min_length=5, max_length=10)
     samples = sample_and_validate(column, generator, n=10_000)
-    assert set(samples.list.len()) == set(range(5, 11))
+    assert set(samples.list.len()) == set(range(5, 11)) | {None}
+
+
+def test_sample_array(generator: Generator) -> None:
+    column = dy.Array(dy.Bool(), (2, 3))
+    samples = sample_and_validate(column, generator, n=10_000)
+    assert samples.is_null().any()
+    assert set(samples.arr.len()) == {2, None}
 
 
 def test_sample_struct(generator: Generator) -> None:
     column = dy.Struct({"a": dy.String(regex="[abc]"), "b": dy.String(regex="[a-z]xx")})
     samples = sample_and_validate(column, generator, n=10_000)
+    assert samples.is_null().any()
     assert len(samples) == 10_000
 
 

{dataframely-1.2.0 → dataframely-1.3.0}/tests/columns/test_sql_schema.py

@@ -139,6 +139,14 @@ def test_raise_for_list_column(dialect: sa.Dialect) -> None:
         dy.List(dy.String()).sqlalchemy_dtype(dialect)
 
 
+@pytest.mark.parametrize("dialect", [MSDialect_pyodbc(), PGDialect_psycopg2()])
+def test_raise_for_array_column(dialect: sa.Dialect) -> None:
+    with pytest.raises(
+        NotImplementedError, match="SQL column cannot have 'Array' type."
+    ):
+        dy.Array(dy.String(), 1).sqlalchemy_dtype(dialect)
+
+
 @pytest.mark.parametrize("dialect", [MSDialect_pyodbc(), PGDialect_psycopg2()])
 def test_raise_for_struct_column(dialect: sa.Dialect) -> None:
     with pytest.raises(

{dataframely-1.2.0 → dataframely-1.3.0}/tests/columns/test_str.py

@@ -24,6 +24,11 @@ def test_string_representation_list() -> None:
     assert str(column) == dy.List.__name__.lower()
 
 
+def test_string_representation_array() -> None:
+    column = dy.Array(dy.String(), 1)
+    assert str(column) == dy.Array.__name__.lower()
+
+
 def test_string_representation_struct() -> None:
     column = dy.Struct({"a": dy.String()})
     assert str(column) == dy.Struct.__name__.lower()

{dataframely-1.2.0 → dataframely-1.3.0}/tests/schema/test_base.py

@@ -18,6 +18,12 @@ class MySchema(dy.Schema):
     d = dy.Any(alias="e")
 
 
+class MySchemaWithRule(MySchema):
+    @dy.rule()
+    def a_greater_than_c() -> pl.Expr:
+        return pl.col("a") > pl.col("c")
+
+
 def test_column_names() -> None:
     assert MySchema.column_names() == ["a", "b", "c", "e"]
 
@@ -75,3 +81,11 @@ def test_col_in_polars_expression() -> None:
         .select(MySchema.a.col)
     )
     assert df.row(0) == (1,)
+
+
+def test_dunder_name() -> None:
+    assert MySchema.__name__ == "MySchema"
+
+
+def test_dunder_name_with_rule() -> None:
+    assert MySchemaWithRule.__name__ == "MySchemaWithRule"