dataframely 2.8.0__tar.gz → 2.8.2__tar.gz

dataframely-2.8.2/.github/copilot-instructions.md

@@ -0,0 +1,53 @@
+# Dataframely
+
+## Package Management
+
+This repository uses the Pixi package manager. When editing `pixi.toml`, run `pixi lock` afterwards.
+
+When running any commands (like `pytest`), prepend them with `pixi run`.
+
+## Code Style
+
+### Documentation
+
+- Document all public functions/methods and classes using docstrings
+  - For functions & methods, use Google Docstrings and include `Args` (if there are any arguments) and `Returns` (if
+    there is a return type).
+  - Do not include type hints in the docstrings
+  - Do not mention default values in the docstrings
+- Do not write docstrings for private functions/methods unless the function is highly complex
+
+### License Headers
+
+Do not manually adjust or add license headers. A pre-commit hook will take care of this.
+
+## Testing
+
+- Never use classes for pytest, but only free functions
+- Do not put `__init__.py` files into test directories
+- Tests should not have docstrings unless they are very complicated or very specific, i.e. warrant a description beyond
+  the test's name
+- All tests should follow the arrange-act-assert pattern. The respective logical blocks should be distinguished via
+  code comments as follows:
+
+  ```python
+  def test_method() -> None:
+      # Arrange
+      ...
+
+      # Act
+      ...
+
+      # Assert
+      ...
+  ```
+
+- If two or more tests are structurally equivalent, they should be merged into a single test and parametrized with
+  `@pytest.mark.parametrize`
+- If at least two tests share the same logic in the "arrange" step, the respective logic should be extracted into a
+  fixture
+
+## Reviewing
+
+When reviewing code changes, make sure that the `SKILL.md` is up-to-date and in line with the public API of this
+package.

{dataframely-2.8.0 → dataframely-2.8.2}/.github/dependabot.yml

@@ -10,3 +10,5 @@ updates:
           - "*"
     commit-message:
       prefix: ci
+    cooldown:
+      default-days: 7

{dataframely-2.8.0 → dataframely-2.8.2}/.github/workflows/build.yml

@@ -57,14 +57,11 @@ jobs:
           environments: build
       - name: Set version
         run: pixi run -e build set-version
-      - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
-        with:
-          python-version: "3.10"
       - name: Build wheel
         uses: PyO3/maturin-action@04ac600d27cdf7a9a280dadf7147097c42b757ad # v1.50.1
         with:
           command: build
-          args: --out dist --release
+          args: --out dist --release -i python3.10
           manylinux: auto
           sccache: true
       - name: Check package
@@ -84,7 +81,7 @@ jobs:
       id-token: write
     environment: pypi
     steps:
-      - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
+      - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c # v8.0.1
         with:
           path: dist
           merge-multiple: true

dataframely-2.8.2/.github/workflows/chore-main.yml

@@ -0,0 +1,21 @@
+name: Chore
+on:
+  push:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  draft-release:
+    name: Draft Release
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: read
+    steps:
+      - name: Update release draft
+        uses: release-drafter/release-drafter@139054aeaa9adc52ab36ddf67437541f039b88e2 # v7.1.1
+        with:
+          token: ${{ github.token }}

dataframely-2.8.0/.github/workflows/chore.yml → dataframely-2.8.2/.github/workflows/chore-pr.yml

@@ -3,8 +3,6 @@ on:
   pull_request_target:
     branches: [main]
     types: [opened, reopened, edited, synchronize]
-  push:
-    branches: [main]
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
@@ -13,7 +11,6 @@ concurrency:
 jobs:
   check-pr-title:
     name: Check PR Title
-    if: github.event_name == 'pull_request_target'
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -28,7 +25,7 @@ jobs:
           GITHUB_TOKEN: ${{ github.token }}
       - name: Post comment about invalid PR title
         if: failure()
-        uses: marocchino/sticky-pull-request-comment@773744901bac0e8cbb5a0dc842800d45e9b2b405 # v2.9.4
+        uses: marocchino/sticky-pull-request-comment@70d2764d1a7d5d9560b100cbea0077fc8f633987 # v3.0.2
         with:
           header: conventional-commit-pr-title
           message: |
@@ -45,22 +42,18 @@ jobs:
             </details>
       - name: Delete comment about invalid PR title
         if: success()
-        uses: marocchino/sticky-pull-request-comment@773744901bac0e8cbb5a0dc842800d45e9b2b405 # v2.9.4
+        uses: marocchino/sticky-pull-request-comment@70d2764d1a7d5d9560b100cbea0077fc8f633987 # v3.0.2
         with:
           header: conventional-commit-pr-title
           delete: true
 
-  release-drafter:
-    name: ${{ github.event_name == 'pull_request_target' && 'Assign Labels' || 'Draft Release' }}
+  assign-labels:
+    name: Assign Labels
     runs-on: ubuntu-latest
     permissions:
-      contents: write
       pull-requests: write
     steps:
-      - name: ${{ github.event_name == 'pull_request_target' && 'Assign labels' || 'Update release draft' }}
-        uses: release-drafter/release-drafter@6db134d15f3909ccc9eefd369f02bd1e9cffdf97 # v6.2.0
+      - name: Assign labels
+        uses: release-drafter/release-drafter/autolabeler@139054aeaa9adc52ab36ddf67437541f039b88e2 # v7.1.1
         with:
-          disable-releaser: ${{ github.event_name == 'pull_request_target' }}
-          disable-autolabeler: ${{ github.event_name == 'push' }}
-        env:
-          GITHUB_TOKEN: ${{ github.token }}
+          token: ${{ github.token }}

{dataframely-2.8.0 → dataframely-2.8.2}/.github/workflows/ci.yml

@@ -30,7 +30,7 @@ jobs:
       - name: Install Rust
         run: rustup show
       - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
       - name: pre-commit
         run: pixi run pre-commit-run --color=always --show-diff-on-failure
 
@@ -71,7 +71,7 @@ jobs:
       - name: Install Rust
         run: rustup show
       - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
       - name: Install repository
         run: pixi run -e ${{ matrix.environment }} postinstall
       - name: Run pytest

{dataframely-2.8.0 → dataframely-2.8.2}/.github/workflows/copilot-setup-steps.yml

@@ -21,6 +21,6 @@ jobs:
       - name: Install Rust
         run: rustup show
       - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@779680da715d629ac1d338a641029a2f4372abb5 # v2.8.2
+        uses: Swatinem/rust-cache@c19371144df3bb44fab255c43d04cbc2ab54d1c4 # v2.9.1
       - name: Install repository
         run: pixi run postinstall

{dataframely-2.8.0 → dataframely-2.8.2}/.github/workflows/scorecard.yml

@@ -74,6 +74,6 @@ jobs:
       # Upload the results to GitHub's code scanning dashboard (optional).
       # Commenting out will disable upload of results to your repo's Code Scanning dashboard
       - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@89a39a4e59826350b863aa6b6252a07ad50cf83e # v3.29.5
+        uses: github/codeql-action/upload-sarif@89a39a4e59826350b863aa6b6252a07ad50cf83e # v4.32.4
         with:
           sarif_file: results.sarif

{dataframely-2.8.0 → dataframely-2.8.2}/PKG-INFO

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

dataframely-2.8.2/SKILL.md

@@ -0,0 +1,238 @@
+---
+name: dataframely
+description: Best practices for polars data processing with dataframely. Covers definitions of Schema and Collection, usage of
+  .validate() and .filter(), type hints, and testing. Use when writing or modifying code involving dataframely or
+  polars data frames.
+license: BSD-3-Clause
+user-invocable: false
+---
+
+# Overview
+
+`dataframely` provides two types:
+
+- `dy.Schema` documents and enforces the structure of a single data frame
+- `dy.Collection` documents and enforces the relationships between multiple related data frames that each have their
+  own `dy.Schema`
+
+## `dy.Schema`
+
+A subclass of `dy.Schema` describes the structure of a single dataframe.
+
+```python
+class MyHouseSchema(dy.Schema):
+    """A schema for a dataframe describing houses."""
+
+    street = dy.String(primary_key=True)
+    number = dy.UInt16(primary_key=True)
+    #: Description on the number of rooms.
+    rooms = dy.UInt8()
+    #: Description on the area of the house.
+    area = dy.UInt16()
+```
+
+The schema can be used in type hints via `dy.DataFrame[MyHouseSchema]` and `dy.LazyFrame[MyHouseSchema]` to express
+schema adherence statically. It can also be used to validate the structure and contents of a data frame at runtime
+using validation and filtering.
+
+`dy.DataFrame[...]` and `dy.LazyFrame[...]` are typically referred to as "typed data frames". They are typing-only
+wrappers around `pl.DataFrame` and `pl.LazyFrame`, respectively, and only express intent. They are never initialized at
+runtime.
+
+### Defining Constraints
+
+Persist all implicit assumptions on the data as constraints in the schema. Use docstrings purely to answer the "what"
+about the column contents.
+
+- Use the most specific type possible for each column (e.g. `dy.Enum` instead of `dy.String` when applicable).
+- Use pre-defined arguments (e.g. `nullable`, `min`, `regex`) for column-level constraints if possible.
+- Use the `check` argument for non-standard column-level constraints that cannot be expressed using pre-defined
+  arguments. Prefer the defining the check as a dictionary with keys describing the type of check:
+
+  ```python
+  class MySchema(dy.Schema):
+      col = dy.UInt8(check={"divisible_by_two": lambda col: (col % 2) == 0})
+  ```
+
+- Use rules (i.e. methods decorated with `@dy.rule`) for cross-column constraints. Use expressive names for the rules
+  and use `cls` to refer to the schema:
+
+  ```python
+  class MySchema(dy.Schema):
+      col1 = dy.UInt8()
+      col2 = dy.UInt8()
+
+      @dy.rule()
+      def col1_greater_col2(cls) -> pl.Expr:
+          return cls.col1.col > cls.col2.col
+  ```
+
+- Use group rules (i.e. methods decorated with `@dy.rule(group_by=...)`) for cross-row constraints beyond primary key
+  checks.
+
+### Referencing Columns
+
+When referencing columns of the schema anywhere in the code, always reference column as attribute of the schema class:
+
+- Use `Schema.column.col` instead of `pl.col("column")` to obtain a `pl.Expr` referencing the column.
+- Use `Schema.column.name` to reference the column name as a string.
+
+This allows for easier refactorings and enables lookups on column definitions and constraints via LSP.
+
+## `dy.Collection`
+
+A subclass of `dy.Collection` describes a set of related data frames, each described by a `dy.Schema`. Data frames in a
+collection should share at least a subset of their primary key.
+
+```python
+class MyStreetSchema(dy.Schema):
+    """A schema for a dataframe describing streets."""
+
+    # Shared primary key component with MyHouseSchema
+    street = dy.String(primary_key=True)
+    city = dy.String()
+
+
+class MyCollection(dy.Collection):
+    """A collection of related dataframes."""
+
+    houses: dy.LazyFrame[MyHouseSchema]
+    streets: dy.LazyFrame[MyStreetSchema]
+```
+
+The collection can be used in a standalone manner (much like a dataclass). It can also be used to validate the
+structure and contents of its members and their relationships at runtime using validation and filtering.
+
+### Defining Constraints
+
+Persist all implicit assumptions about the relationships between the collections' data frames as constraints in the
+collection.
+
+- Use filters (i.e. methods decorated with `@dy.filter`) to enforce assumptions about the relationships (e.g. 1:1, 1:N)
+  between the collections' data frames. Leverage `dy.functional` for writing filter logic.
+
+  ```python
+  class MyCollection(dy.Collection):
+      houses: dy.LazyFrame[MyHouseSchema]
+      streets: dy.LazyFrame[MyStreetSchema]
+
+      @dy.filter()
+      def all_houses_on_known_streets(cls) -> pl.LazyFrame:
+          return dy.functional.require_relationship_one_to_at_least_one(
+              cls.streets, cls.houses, on="street"
+          )
+  ```
+
+# Usage Conventions
+
+## Clear Interfaces
+
+Structure data processing code with clear interfaces documented using `dataframely` type hints:
+
+```python
+def preprocess(raw: dy.LazyFrame[MyRawSchema]) -> dy.DataFrame[MyPreprocessedSchema]:
+    # Internal data frames do not require schemas
+    df: pl.LazyFrame = ...
+    return MyPreprocessedSchema.validate(df, cast=True)
+```
+
+- Use schemas for all input and output data frames in a function. Omit type hints if the function is a private helper
+  (prefixed with `_`) unless the schema critically improves readability or testability.
+- Omit schemas for short-lived temporary data frames. Never define schemas for function-local data frames.
+
+## Validation and Filtering
+
+Both `.validate` and `.filter` enforce the schema at runtime. Pass `cast=True` for safe type-casting.
+
+- **`Schema.validate`** — raises on failure. Use when failures are unexpected (e.g. transforming already-validated
+  data).
+- **`Schema.filter`** — returns valid rows plus a `FailureInfo` describing filtered-out rows. Use when failures are
+  possible and should be handled gracefully. Failures should either be kept around or logged for introspection. The
+  `FailureInfo` object provides several utility methods to obtain information about the failures:
+  - `len(failure)` provides the total number of failures
+  - `failure.counts()` provides the number of violations by rule
+  - `failure.invalid()` provides the data frame of invalid rows
+  - `failure.details()` provides the data frame of invalid rows with additional columns providing information on which
+    rules were violated
+
+When performing validation or filtering, prefer using `pipe` to clarify the flow of data:
+
+```python
+result = df.pipe(MySchema.validate)
+out, failures = df.pipe(MySchema.filter)
+```
+
+### Pure Casting
+
+Use `Schema.cast` as an escape-hatch when it is already known that the data frame conforms to the schema and the
+runtime cost of the validation should not be incurred. Generally, prefer using `Schema.validate` or `Schema.filter`.
+
+## Testing
+
+Unless otherwise specified by the user or the project context, add unit tests for all (non-private) methods performing
+data transformations.
+
+- Do not test properties already guaranteed by the schema (e.g. data types, nullability, value constraints).
+
+### Test structure
+
+Write tests with the following structure:
+
+1. "Arrange": Define synthetic input data and expected output
+2. "Act": Execute the transformation
+3. "Assert": Compare expected and actual output using `assert_frame_equal` from `polars.testing`
+
+```python
+from polars.testing import assert_frame_equal
+
+
+def test_grouped_sum():
+    df = pl.DataFrame({
+        "col1": [1, 2, 3],
+        "col2": ["a", "a", "b"],
+    }).pipe(MyInputSchema.validate, cast=True)
+
+    expected = pl.DataFrame({
+        "col1": ["a", "b"],
+        "col2": [3, 3],
+    })
+
+    result = my_code(df)
+
+    assert_frame_equal(expected, result)
+```
+
+### Generating Synthetic Test Data
+
+Use `dataframely`'s synthetic data generation for creating inputs to functions requiring typed data frames in their
+input. Generate synthetic data for schemas as follows:
+
+- Use `MySchema.sample(num_rows=...)` to generate fully random data when exact contents don't matter.
+- Use `MySchema.sample(overrides=...)` to generate random data with specific columns pinned to certain values for
+  testing specific functionality. Prefer using dicts of lists for overrides unless specifically prompted otherwise.
+  - When using dicts of lists: for providing overrides that are constant across all rows, provide scalar values instead
+    of lists of equal values.
+- Always use `MySchema.create_empty()` instead of sampling with empty overrides when an empty data frame is needed.
+
+Synthetic data for collections should be generated as follows:
+
+- Use `MyCollection.sample(num_rows=...)` to generate fully random data when exact contents don't matter.
+- Use `MyCollection.sample(overrides=...)` to generate random data where certain values of the collection members
+  matter. Use lists of dicts for providing overrides as "objects" spanning the collection members.
+  - Values for shared primary keys must be provided at the root of the dictionaries
+  - Values for individual collection members must be provided in nested dictionaries under the keys corresponding to
+    the collection member names.
+- Always use `MyCollection.create_empty()` instead of sampling with empty overrides when an empty collection is needed.
+
+## I/O Conventions
+
+When writing typed data frames to disk, prefer using `MySchema.write_...` instead of using `write_...` directly on the
+data frame. This ensures that schema metadata is persisted alongside the data and can be leveraged when reading the
+data back in.
+
+When reading typed data frames from disk, prefer using `MySchema.read_...` instead of using `pl.read_...` directly from
+
+# Getting more information
+
+`dataframely` provides clear function signatures, type hints and docstrings for the full public API. For more
+information, inspect the source code in the site packages. If available, always use the LSP tool to find documentation.

{dataframely-2.8.0 → dataframely-2.8.2}/dataframely/_base_schema.py

@@ -119,7 +119,9 @@ class SchemaMeta(ABCMeta):
         result = Metadata()
         for base in bases:
             result.update(mcs._get_metadata_recursively(base))
-        result.update(mcs._get_metadata(namespace))
+        namespace_metadata = mcs._get_metadata(namespace)
+        mcs._remove_overridden_columns(result, namespace, bases)
+        result.update(namespace_metadata)
         namespace[_COLUMN_ATTR] = result.columns
         cls = super().__new__(mcs, name, bases, namespace, *args, **kwargs)
 
@@ -207,6 +209,34 @@ class SchemaMeta(ABCMeta):
                 val._name = val.alias or name
             return val
 
+    @staticmethod
+    def _remove_overridden_columns(
+        result: Metadata,
+        namespace: dict[str, Any],
+        bases: tuple[type[object], ...],
+    ) -> None:
+        """Remove inherited columns that the child namespace explicitly overrides.
+
+        Before merging the child namespace, we must drop any parent columns whose
+        attribute name is redefined in the child. This allows subclasses to redefine
+        inherited columns while still detecting genuine alias conflicts.
+
+        In multiple-inheritance scenarios, the same attribute name may appear in more
+        than one base with different aliases, so we walk all parent MROs and collect
+        every matching column key to remove.
+        """
+        for attr, value in namespace.items():
+            if not isinstance(value, Column):
+                continue
+            keys_to_remove: set[str] = set()
+            for base in bases:
+                for parent_cls in base.__mro__:
+                    parent_col = parent_cls.__dict__.get(attr)
+                    if parent_col is not None and isinstance(parent_col, Column):
+                        keys_to_remove.add(parent_col.alias or attr)
+            for parent_key in keys_to_remove:
+                result.columns.pop(parent_key, None)
+
     @staticmethod
     def _get_metadata_recursively(kls: type[object]) -> Metadata:
         result = Metadata()

{dataframely-2.8.0 → dataframely-2.8.2}/docs/conf.py

@@ -22,7 +22,6 @@ from typing import Any, cast
 
 _mod = importlib.import_module("dataframely")
 
-
 project = "dataframely"
 copyright = f"{datetime.date.today().year}, QuantCo, Inc"
 author = "QuantCo, Inc."

dataframely-2.8.2/docs/guides/coding-agents.md

@@ -0,0 +1,75 @@
+# Using `dataframely` with coding agents
+
+Coding agents like [Claude Code](https://code.claude.com/), [Codex](https://openai.com/codex/) and
+[GitHub Copilot](https://github.com/features/copilot) are particularly powerful when two criteria are met:
+
+1. The agent has access to the full context required to solve the problem, i.e. does not have to guess.
+2. The results of the agent's work can be easily verified.
+
+When writing data processing logic, `dataframely` helps to fulfill these criteria.
+
+To help your coding agent write idiomatic `dataframely` code, we provide a `dataframely`
+[skill](https://raw.githubusercontent.com/Quantco/dataframely/refs/heads/main/SKILL.md) following the
+[`agentskills.io` spec](https://agentskills.io/specification). You can install it by placing it where your agent can
+find it. For example, if you are using Claude Code:
+
+```bash
+mkdir -p .claude/skills/dataframely/
+curl -o .claude/skills/dataframely/SKILL.md https://raw.githubusercontent.com/Quantco/dataframely/refs/heads/main/SKILL.md
+```
+
+or if you are using [skills.sh](https://skills.sh/) to manage your skills:
+
+```bash
+npx skills add Quantco/dataframely
+```
+
+Refer to the documentation of your coding agent for instructions on how to add custom skills.
+
+## Tell the agent about your data with `dataframely` schemas
+
+`dataframely` schemas provide a clear format for documenting dataframe structure and contents, which helps coding
+agents understand your code base. We recommend structuring your data processing code using clear interfaces that are
+documented using `dataframely` type hints. This streamlines your coding agent's ability to find the right schema at the
+right time.
+
+For example:
+
+```python
+def preprocess(raw: dy.LazyFrame[MyRawSchema]) -> dy.DataFrame[MyPreprocessedSchema]:
+    ...
+```
+
+gives a coding agent much more information than the schema-less alternative:
+
+```python
+def load_data(raw: pl.LazyFrame) -> pl.DataFrame:
+    ...
+```
+
+This convention also makes your code more readable and maintainable for human developers.
+
+If there is additional domain information that is not natively expressed through the structure of the schema, we
+recommend documenting this as docstrings on the definition of the schema columns. One common example would be the
+semantic meanings of enum values referring to conventions in the data:
+
+```python
+class HospitalStaySchema(dy.Schema):
+    # Reason for admission to the hospital
+    # N = Emergency
+    # V = Transfer from another hospital
+    # ...
+    admission_reason = dy.Enum(["N", "V", ...])
+```
+
+## Verifying results
+
+`dataframely` supports you and your coding agent in writing unit tests for individual pieces of logic. One significant
+bottleneck is the generation of appropriate test data. Check out
+[our documentation on synthetic data generation](./features/data-generation.md) to see how `dataframely` can help you
+generate realistic test data that meets the constraints of your schema. We recommend requiring your coding agent to
+write tests using this functionality to verify its work.
+
+<!-- prettier-ignore -->
+> [!NOTE]
+> The official skill already tells your coding agent how to best write unit tests with dataframely.

{dataframely-2.8.0 → dataframely-2.8.2}/docs/guides/index.md

@@ -7,6 +7,7 @@
 quickstart
 examples/index
 features/index
+coding-agents
 development
 migration/index
 faq

{dataframely-2.8.0 → dataframely-2.8.2}/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.8.0"
+version = "2.8.2"
 
 [project.optional-dependencies]
 deltalake = ["deltalake"]

{dataframely-2.8.0 → dataframely-2.8.2}/tests/schema/test_base.py

@@ -141,3 +141,22 @@ def test_user_error_polars_datatype_type() -> None:
         class MySchemaWithPolarsDataTypeType(dy.Schema):
             a = dy.Int32(nullable=False)
             b = pl.String  # User error: Used pl.String instead of dy.String()
+
+
+def test_override() -> None:
+    class FirstSchema(dy.Schema):
+        x = dy.Int64()
+
+    class SecondSchema(FirstSchema):
+        x = dy.Int64(nullable=True)
+
+    first_columns = FirstSchema.columns()
+    second_columns = SecondSchema.columns()
+
+    assert set(first_columns) == {"x"}
+    assert set(second_columns) == {"x"}
+
+    assert first_columns["x"].nullable is False
+    assert second_columns["x"].nullable is True
+
+    assert type(second_columns["x"]) is type(first_columns["x"])