dataframely 1.4.0__tar.gz → 1.6.0__tar.gz

{dataframely-1.4.0 → dataframely-1.6.0}/.copier-answers.yml

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

dataframely-1.6.0/.gitattributes

@@ -0,0 +1 @@
+pixi.lock merge=binary linguist-language=YAML linguist-generated=true

{dataframely-1.4.0 → dataframely-1.6.0}/.github/workflows/build.yml

@@ -10,6 +10,8 @@ jobs:
   build-sdist:
     name: Build Sdist
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
     steps:
       - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
         with:

{dataframely-1.4.0 → dataframely-1.6.0}/.github/workflows/chore.yml

@@ -21,14 +21,14 @@ jobs:
     steps:
       - name: Check valid conventional commit message
         id: lint
-        uses: amannn/action-semantic-pull-request@v5
+        uses: amannn/action-semantic-pull-request@0723387faaf9b38adef4775cd42cfd5155ed6017 # v5.5.3
         with:
           subjectPattern: ^[A-Z].+[^. ]$ # subject must start with uppercase letter and may not end with a dot/space
         env:
           GITHUB_TOKEN: ${{ github.token }}
       - name: Post comment about invalid PR title
         if: failure()
-        uses: marocchino/sticky-pull-request-comment@v2
+        uses: marocchino/sticky-pull-request-comment@52423e01640425a022ef5fd42c6fb5f633a02728 # v2.9.1
         with:
           header: conventional-commit-pr-title
           message: |
@@ -45,7 +45,7 @@ jobs:
             </details>
       - name: Delete comment about invalid PR title
         if: success()
-        uses: marocchino/sticky-pull-request-comment@v2
+        uses: marocchino/sticky-pull-request-comment@52423e01640425a022ef5fd42c6fb5f633a02728 # v2.9.1
         with:
           header: conventional-commit-pr-title
           delete: true
@@ -58,7 +58,7 @@ jobs:
       pull-requests: write
     steps:
       - name: ${{ github.event_name == 'pull_request_target' && 'Assign labels' || 'Update release draft' }}
-        uses: release-drafter/release-drafter@v6
+        uses: release-drafter/release-drafter@b1476f6e6eb133afa41ed8589daba6dc69b4d3f5 # v6.1.0
         with:
           disable-releaser: ${{ github.event_name == 'pull_request_target' }}
           disable-autolabeler: ${{ github.event_name == 'push' }}

{dataframely-1.4.0 → dataframely-1.6.0}/.github/workflows/ci.yml

@@ -9,6 +9,9 @@ concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}
   cancel-in-progress: true
 
+permissions:
+  contents: read
+
 jobs:
   pre-commit-checks:
     name: Pre-commit Checks
@@ -40,7 +43,7 @@ jobs:
         environment: [py311, py312, py313]
     steps:
       - name: Checkout branch
-        uses: actions/checkout@v4
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
       - name: Set up pixi
         uses: prefix-dev/setup-pixi@19eac09b398e3d0c747adc7921926a6d802df4da # v0.8.8
         with:
@@ -50,7 +53,7 @@ jobs:
       - name: Run pytest
         run: pixi run -e ${{ matrix.environment }} test-coverage --color=yes
       - name: Upload codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@18283e04ce6e62d37312384ff67231eb8fd56d24 # v5.4.3
         with:
           files: ./coverage.xml
           token: ${{ secrets.CODECOV_TOKEN }}

dataframely-1.6.0/.github/workflows/scorecard.yml

@@ -0,0 +1,79 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+  # For Branch-Protection check. Only the default branch is supported. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+  branch_protection_rule:
+  # To guarantee Maintained check is occasionally updated. See
+  # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+  schedule:
+    - cron: "34 5 * * 0"
+  workflow_dispatch:
+  push:
+    branches: ["main"]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+  analysis:
+    name: Scorecard analysis
+    runs-on: ubuntu-latest
+    # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.
+    if: (github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request') && github.repository == 'quantco/dataframely'
+    permissions:
+      # Needed to upload the results to code-scanning dashboard.
+      security-events: write
+      # Needed to publish results and get a badge (see publish_results below).
+      id-token: write
+      # Uncomment the permissions below if installing in a private repository.
+      # contents: read
+      # actions: read
+
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          persist-credentials: false
+
+      - name: "Run analysis"
+        uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
+        with:
+          results_file: results.sarif
+          results_format: sarif
+          # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+          # - you want to enable the Branch-Protection check on a *public* repository, or
+          # - you are installing Scorecard on a *private* repository
+          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
+          # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+          # Public repositories:
+          #   - Publish results to OpenSSF REST API for easy access by consumers
+          #   - Allows the repository to include the Scorecard badge.
+          #   - See https://github.com/ossf/scorecard-action#publishing-results.
+          # For private repositories:
+          #   - `publish_results` will always be set to `false`, regardless
+          #     of the value entered here.
+          publish_results: true
+
+          # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore
+          # file_mode: git
+
+      # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+      # format to the repository Actions tab.
+      - name: "Upload artifact"
+        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
+        with:
+          name: SARIF file
+          path: results.sarif
+          retention-days: 5
+
+      # 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@ff0a06e83cb2de871e5a09832bc6a81e7276941f # v3.28.18
+        with:
+          sarif_file: results.sarif

{dataframely-1.4.0 → dataframely-1.6.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: dataframely
-Version: 1.4.0
+Version: 1.6.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: numpy
-Requires-Dist: polars>=1.12
+Requires-Dist: polars>=1.30
 License-File: LICENSE
 Summary: A declarative, polars-native data frame validation library
 Author-email: Andreas Albert <andreas.albert@quantco.com>, Daniel Elsner <daniel.elsner@quantco.com>, Oliver Borchert <oliver.borchert@quantco.com>
@@ -28,7 +28,7 @@ Project-URL: Repository, https://github.com/quantco/dataframely
 [![conda-forge](https://img.shields.io/conda/vn/conda-forge/dataframely?logoColor=white&logo=conda-forge&style=flat-square)](https://prefix.dev/channels/conda-forge/packages/dataframely)
 [![pypi-version](https://img.shields.io/pypi/v/dataframely.svg?logo=pypi&logoColor=white&style=flat-square)](https://pypi.org/project/dataframely)
 [![python-version](https://img.shields.io/pypi/pyversions/dataframely?logoColor=white&logo=python&style=flat-square)](https://pypi.org/project/dataframely)
-[![codecov](https://codecov.io/gh/Quantco/dataframely/graph/badge.svg)](https://codecov.io/gh/Quantco/dataframely)
+[![codecov](https://codecov.io/gh/Quantco/dataframely/graph/badge.svg?token=QOvhS7Zri2)](https://codecov.io/gh/Quantco/dataframely)
 
 </div>
 

{dataframely-1.4.0 → dataframely-1.6.0}/README.md

@@ -11,7 +11,7 @@
 [![conda-forge](https://img.shields.io/conda/vn/conda-forge/dataframely?logoColor=white&logo=conda-forge&style=flat-square)](https://prefix.dev/channels/conda-forge/packages/dataframely)
 [![pypi-version](https://img.shields.io/pypi/v/dataframely.svg?logo=pypi&logoColor=white&style=flat-square)](https://pypi.org/project/dataframely)
 [![python-version](https://img.shields.io/pypi/pyversions/dataframely?logoColor=white&logo=python&style=flat-square)](https://pypi.org/project/dataframely)
-[![codecov](https://codecov.io/gh/Quantco/dataframely/graph/badge.svg)](https://codecov.io/gh/Quantco/dataframely)
+[![codecov](https://codecov.io/gh/Quantco/dataframely/graph/badge.svg?token=QOvhS7Zri2)](https://codecov.io/gh/Quantco/dataframely)
 
 </div>
 

dataframely-1.6.0/SECURITY.md

@@ -0,0 +1,7 @@
+# Reporting Security Issues
+
+We take security bugs in our projects seriously. We appreciate your efforts to responsibly disclose your findings, and will make every effort to acknowledge your contributions.
+
+To report a security issue, please use the GitHub Security Advisory ["Report a Vulnerability"](https://github.com/quantco/dataframely/security/advisories/new) tab.
+
+We will send a response indicating the next steps in handling your report. After the initial reply to your report, the security team will keep you informed of the progress towards a fix and full announcement, and may ask for additional information or guidance.

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/__init__.py

@@ -51,7 +51,7 @@ from .functional import (
     filter_relationship_one_to_at_least_one,
     filter_relationship_one_to_one,
 )
-from .schema import Schema
+from .schema import Schema, deserialize_schema
 
 __all__ = [
     "random",
@@ -67,6 +67,7 @@ __all__ = [
     "filter_relationship_one_to_at_least_one",
     "filter_relationship_one_to_one",
     "Schema",
+    "deserialize_schema",
     "Any",
     "Bool",
     "Column",

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/_base_collection.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import textwrap
 import typing
 from abc import ABCMeta
 from collections.abc import Iterable
@@ -245,6 +246,32 @@ class CollectionMeta(ABCMeta):
             # Some other unknown annotation
             raise AnnotationImplementationError(attr, type_annotation)
 
+    def __repr__(cls) -> str:
+        parts = [f'[Collection "{cls.__class__.__name__}"]']
+        parts.append(textwrap.indent("Members:", prefix=" " * 2))
+        for name, member in cls.members().items():  # type: ignore
+            parts.append(
+                textwrap.indent(
+                    f'- "{name}": {member.schema.__name__}'
+                    f"(optional={member.is_optional}, "
+                    f"ignored_in_filters={member.ignored_in_filters}, "
+                    f"inline_for_sampling={member.inline_for_sampling})",
+                    prefix=" " * 4,
+                )
+            )
+        if filters := cls._filters():  # type: ignore
+            parts.append(textwrap.indent("Filters:", prefix=" " * 2))
+            for name, member in filters.items():
+                parts.append(textwrap.indent(f'- "{name}":', prefix=" " * 4))
+                parts.append(
+                    textwrap.indent(
+                        f"{member.logic(cls.create_empty()).explain()}",  # type: ignore
+                        prefix=" " * 8,
+                    )
+                )
+        parts.append("")  # Add line break at the end
+        return "\n".join(parts)
+
 
 class BaseCollection(metaclass=CollectionMeta):
     """Internal utility abstraction to reference collections without introducing

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/_base_schema.py

@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import textwrap
 from abc import ABCMeta
 from copy import copy
 from dataclasses import dataclass, field
@@ -10,9 +11,9 @@ from typing import Any, Self
 
 import polars as pl
 
-from ._rule import GroupRule, Rule, with_evaluation_rules
+from ._rule import GroupRule, Rule
 from .columns import Column
-from .exc import ImplementationError, RuleImplementationError
+from .exc import ImplementationError
 
 _COLUMN_ATTR = "__dataframely_columns__"
 _RULE_ATTR = "__dataframely_rules__"
@@ -111,25 +112,15 @@ class SchemaMeta(ABCMeta):
                         f"which are not in the schema: {missing_list}."
                     )
 
-        # 3) Assuming that non-custom rules are implemented correctly, we check that all
-        # custom rules are _also_ implemented correctly by evaluating rules on an
-        # empty data frame and checking for the evaluated dtypes.
-        if len(result.rules) > 0:
-            lf_empty = pl.LazyFrame(
-                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 rule_name, rule in result.rules.items():
-                dtype = schema[rule_name]
-                if not isinstance(dtype, pl.Boolean):
-                    raise RuleImplementationError(
-                        rule_name, dtype, isinstance(rule, GroupRule)
-                    )
-
         return super().__new__(mcs, name, bases, namespace, *args, **kwargs)
 
+    def __getattribute__(cls, name: str) -> Any:
+        val = super().__getattribute__(name)
+        # Dynamically set the name of the column if it is a `Column` instance.
+        if isinstance(val, Column):
+            val._name = val.alias or name
+        return val
+
     @staticmethod
     def _get_metadata_recursively(kls: type[object]) -> Metadata:
         result = Metadata()
@@ -145,9 +136,7 @@ class SchemaMeta(ABCMeta):
             k: v for k, v in source.items() if not k.startswith("__")
         }.items():
             if isinstance(value, Column):
-                if not value.alias:
-                    value.alias = attr
-                result.columns[value.alias] = value
+                result.columns[value.alias or attr] = value
             if isinstance(value, Rule):
                 # We must ensure that custom rules do not clash with internal rules.
                 if attr == "primary_key":
@@ -157,6 +146,18 @@ class SchemaMeta(ABCMeta):
                 result.rules[attr] = value
         return result
 
+    def __repr__(cls) -> str:
+        parts = [f'[Schema "{cls.__name__}"]']
+        parts.append(textwrap.indent("Columns:", prefix=" " * 2))
+        for name, col in cls.columns().items():
+            parts.append(textwrap.indent(f'- "{name}": {col!r}', prefix=" " * 4))
+        if validation_rules := cls._schema_validation_rules():
+            parts.append(textwrap.indent("Rules:", prefix=" " * 2))
+            for name, rule in validation_rules.items():
+                parts.append(textwrap.indent(f'- "{name}": {rule!r}', prefix=" " * 4))
+        parts.append("")  # Add line break at the end
+        return "\n".join(parts)
+
 
 class BaseSchema(metaclass=SchemaMeta):
     """Internal utility abstraction to reference schemas without introducing cyclical

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/_deprecation.py

@@ -37,3 +37,14 @@ def warn_nullable_default_change() -> None:
         FutureWarning,
         stacklevel=4,
     )
+
+
+@skip_if(env="DATAFRAMELY_NO_FUTURE_WARNINGS")
+def warn_no_nullable_primary_keys() -> None:
+    warnings.warn(
+        "Nullable primary keys are not supported. "
+        "Setting `nullable=True` on a primary key column is ignored "
+        "and will raise an error in a future release.",
+        FutureWarning,
+        stacklevel=4,
+    )

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/_filter.py

@@ -34,6 +34,12 @@ def filter() -> Callable[[Callable[[C], pl.LazyFrame]], Filter[C]]:
     Attention:
         Make sure to provide unique combinations of the primary keys or the filters
         might introduce duplicate rows.
+
+    Attention:
+        The filter logic should return a lazy frame with a static computational graph.
+        Other implementations using arbitrary python logic works for filtering and
+        validation, but may lead to wrong results in Collection comparisons
+        and (de-)serialization.
     """
 
     def decorator(validation_fn: Callable[[C], pl.LazyFrame]) -> Filter[C]:

{dataframely-1.4.0 → dataframely-1.6.0}/dataframely/_rule.py

@@ -1,8 +1,11 @@
 # Copyright (c) QuantCo 2025-2025
 # SPDX-License-Identifier: BSD-3-Clause
 
+from __future__ import annotations
+
 from collections import defaultdict
 from collections.abc import Callable
+from typing import Any, Self
 
 import polars as pl
 
@@ -12,17 +15,68 @@ ValidationFunction = Callable[[], pl.Expr]
 class Rule:
     """Internal class representing validation rules."""
 
-    def __init__(self, expr: pl.Expr) -> None:
-        self.expr = expr
+    def __init__(self, expr: pl.Expr | ValidationFunction) -> None:
+        self._expr = expr
+
+    @property
+    def expr(self) -> pl.Expr:
+        """Get the expression of the rule."""
+        if callable(self._expr):
+            return self._expr()
+        return self._expr
+
+    def matches(self, other: Rule) -> bool:
+        """Check whether this rule semantically matches another rule.
+
+        Args:
+            other: The rule to compare with.
+
+        Returns:
+            Whether the rules are semantically equal.
+        """
+        return self.expr.meta.eq(other.expr)
+
+    def as_dict(self) -> dict[str, Any]:
+        """Turn the rule into a dictionary."""
+        return {"rule_type": self.__class__.__name__, "expr": self.expr}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        """Read the rule from a dictionary.
+
+        Args:
+            data: The dictionary that was created via :meth:`asdict`.
+        """
+        return cls(data["expr"])
+
+    def __repr__(self) -> str:
+        return str(self.expr)
 
 
 class GroupRule(Rule):
     """Rule that is evaluated on a group of columns."""
 
-    def __init__(self, expr: pl.Expr, group_columns: list[str]) -> None:
+    def __init__(
+        self, expr: pl.Expr | ValidationFunction, group_columns: list[str]
+    ) -> None:
         super().__init__(expr)
         self.group_columns = group_columns
 
+    def matches(self, other: Rule) -> bool:
+        if not isinstance(other, GroupRule):
+            return False
+        return super().matches(other) and self.group_columns == other.group_columns
+
+    def as_dict(self) -> dict[str, Any]:
+        return {**super().as_dict(), "group_columns": self.group_columns}
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Self:
+        return cls(data["expr"], group_columns=data["group_columns"])
+
+    def __repr__(self) -> str:
+        return f"{super().__repr__()} grouped by {self.group_columns}"
+
 
 def rule(*, group_by: list[str] | None = None) -> Callable[[ValidationFunction], Rule]:
     """Mark a function as a rule to evaluate during validation.
@@ -52,12 +106,18 @@ def rule(*, group_by: list[str] | None = None) -> Callable[[ValidationFunction],
         rules. By default, any rule that evaluates to ``null`` because one of the
         columns used in the rule is ``null`` is interpreted as ``true``, i.e. the row
         is assumed to be valid.
+
+    Attention:
+        The rule logic should return a static result.
+        Other implementations using arbitrary python logic works for filtering and
+        validation, but may lead to wrong results in Schema comparisons
+        and (de-)serialization.
     """
 
     def decorator(validation_fn: ValidationFunction) -> Rule:
         if group_by is not None:
-            return GroupRule(expr=validation_fn(), group_columns=group_by)
-        return Rule(expr=validation_fn())
+            return GroupRule(expr=validation_fn, group_columns=group_by)
+        return Rule(expr=validation_fn)
 
     return decorator
 
@@ -130,3 +190,30 @@ def _with_group_rules(lf: pl.LazyFrame, rules: dict[str, GroupRule]) -> pl.LazyF
             frame, on=list(group_columns), how="left", nulls_equal=True
         )
     return result
+
+
+# ------------------------------------------------------------------------------------ #
+#                                        FACTORY                                       #
+# ------------------------------------------------------------------------------------ #
+
+_TYPE_MAPPING: dict[str, type[Rule]] = {
+    Rule.__name__: Rule,
+    GroupRule.__name__: GroupRule,
+}
+
+
+def rule_from_dict(data: dict[str, Any]) -> Rule:
+    """Dynamically read a rule object from a dictionary.
+
+    Args:
+        data: The dictionary obtained by calling :meth:`~Rule.asdict` on a rule object.
+            The dictionary must contain a key ``"rule_type"`` that indicates which rule
+            type to instantiate.
+
+    Returns:
+        The rule object as read from ``data``.
+    """
+    name = data["rule_type"]
+    if name not in _TYPE_MAPPING:
+        raise ValueError(f"Unknown rule type: {name}")
+    return _TYPE_MAPPING[name].from_dict(data)

dataframely-1.6.0/dataframely/_serialization.py

@@ -0,0 +1,88 @@
+# Copyright (c) QuantCo 2025-2025
+# SPDX-License-Identifier: BSD-3-Clause
+
+import datetime as dt
+import decimal
+from io import BytesIO
+from json import JSONDecoder, JSONEncoder
+from typing import Any, cast
+
+import polars as pl
+
+
+class SchemaJSONEncoder(JSONEncoder):
+    """Custom JSON encoder to properly serialize all types serialized by schemas."""
+
+    def encode(self, obj: Any) -> str:
+        def hint_tuples(item: Any) -> Any:
+            if isinstance(item, tuple):
+                return {"__type__": "tuple", "value": list(item)}
+            if isinstance(item, list):
+                return [hint_tuples(i) for i in item]
+            if isinstance(item, dict):
+                return {k: hint_tuples(v) for k, v in item.items()}
+            return item
+
+        return super().encode(hint_tuples(obj))
+
+    def default(self, obj: Any) -> Any:
+        match obj:
+            case pl.Expr():
+                return {
+                    "__type__": "expression",
+                    "value": obj.meta.serialize(format="json"),
+                }
+            case decimal.Decimal():
+                return {"__type__": "decimal", "value": str(obj)}
+            case dt.datetime():
+                return {"__type__": "datetime", "value": obj.isoformat()}
+            case dt.date():
+                return {"__type__": "date", "value": obj.isoformat()}
+            case dt.time():
+                return {"__type__": "time", "value": obj.isoformat()}
+            case dt.timedelta():
+                return {"__type__": "timedelta", "value": obj.total_seconds()}
+            case dt.tzinfo():
+                offset = obj.utcoffset(dt.datetime.now())
+                return {
+                    "__type__": "tzinfo",
+                    "value": offset.total_seconds() if offset is not None else None,
+                }
+            case _:
+                return super().default(obj)
+
+
+class SchemaJSONDecoder(JSONDecoder):
+    """Custom JSON decoder to properly deserialize all types serialized by schemas."""
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(object_hook=self.object_hook, *args, **kwargs)
+
+    def object_hook(self, dct: dict[str, Any]) -> Any:
+        if "__type__" not in dct:
+            return dct
+
+        match dct["__type__"]:
+            case "tuple":
+                return tuple(dct["value"])
+            case "expression":
+                data = BytesIO(cast(str, dct["value"]).encode("utf-8"))
+                return pl.Expr.deserialize(data, format="json")
+            case "decimal":
+                return decimal.Decimal(dct["value"])
+            case "datetime":
+                return dt.datetime.fromisoformat(dct["value"])
+            case "date":
+                return dt.date.fromisoformat(dct["value"])
+            case "time":
+                return dt.time.fromisoformat(dct["value"])
+            case "timedelta":
+                return dt.timedelta(seconds=float(dct["value"]))
+            case "tzinfo":
+                return (
+                    dt.timezone(dt.timedelta(seconds=float(dct["value"])))
+                    if dct["value"] is not None
+                    else dt.timezone(dt.timedelta(0))
+                )
+            case _:
+                raise TypeError(f"Unknown type '{dct['__type__']}' in JSON data.")