dyff-schema 0.29.0__py3-none-any.whl → 0.30.1__py3-none-any.whl

dyff/schema/v0/r1/commands.py

@@ -10,8 +10,10 @@ from __future__ import annotations
 from typing import Literal, Optional, Union
 
 import pydantic
+from pydantic import StringConstraints
+from typing_extensions import Annotated
 
-from .base import DyffSchemaBaseModel, JsonMergePatchSemantics, Null
+from .base import DyffSchemaBaseModel, JsonMergePatchSemantics
 from .platform import (
     DyffEntityType,
     EntityIdentifier,
@@ -26,20 +28,6 @@ from .platform import (
     title_maxlen,
 )
 
-# ----------------------------------------------------------------------------
-
-
-# class _NoneMeansUndefined(DyffSchemaBaseModel):
-#     """Fields with the value None will not be emitted in the JSON output."""
-
-#     # TODO: (DYFF-223) This should perhaps be the default for all schema
-#     # objects.
-#     def dict(self, *, exclude_none=True, **kwargs) -> _ModelAsDict:
-#         return super().dict(exclude_none=True, **kwargs)
-
-#     def json(self, *, exclude_none=True, **kwargs) -> str:
-#         return super().json(exclude_none=True, **kwargs)
-
 
 class FamilyIdentifier(EntityIdentifier):
     """Identifies a single Family entity."""
@@ -87,7 +75,7 @@ class EditEntityDocumentationPatch(JsonMergePatchSemantics):
     Fields that are assigned explicitly remain unchanged.
     """
 
-    title: Optional[Union[pydantic.constr(max_length=title_maxlen()), Null]] = (  # type: ignore
+    title: Optional[Annotated[str, StringConstraints(max_length=title_maxlen())]] = (  # type: ignore
         pydantic.Field(
             default=None,
             description='A short plain string suitable as a title or "headline".'
@@ -95,7 +83,7 @@ class EditEntityDocumentationPatch(JsonMergePatchSemantics):
         )
     )
 
-    summary: Optional[Union[pydantic.constr(max_length=summary_maxlen()), Null]] = (  # type: ignore
+    summary: Optional[Annotated[str, StringConstraints(max_length=summary_maxlen())]] = (  # type: ignore
         pydantic.Field(
             default=None,
             description="A brief summary, suitable for display in"
@@ -104,7 +92,7 @@ class EditEntityDocumentationPatch(JsonMergePatchSemantics):
         )
     )
 
-    fullPage: Optional[Union[str, Null]] = pydantic.Field(
+    fullPage: Optional[str] = pydantic.Field(
         default=None,
         description="Long-form documentation. Interpreted as"
         " Markdown. There are no length constraints, but be reasonable."
@@ -146,7 +134,7 @@ class EditEntityDocumentation(Command):
 class EditEntityLabelsAttributes(JsonMergePatchSemantics):
     """Attributes for the EditEntityLabels command."""
 
-    labels: dict[LabelKeyType, Optional[Union[LabelValueType, Null]]] = pydantic.Field(
+    labels: dict[LabelKeyType, Optional[LabelValueType]] = pydantic.Field(
         default_factory=dict,
         description="A set of key-value labels for the resource."
         " Existing label keys that are not provided in the edit remain unchanged."
@@ -180,7 +168,7 @@ class EditEntityLabels(Command):
 class EditFamilyMembersAttributes(JsonMergePatchSemantics):
     """Attributes for the EditFamilyMembers command."""
 
-    members: dict[TagNameType, Optional[Union[FamilyMember, Null]]] = pydantic.Field(
+    members: dict[TagNameType, Optional[FamilyMember]] = pydantic.Field(
         description="Mapping of names to IDs of member resources.",
     )
 
@@ -259,12 +247,10 @@ class RestoreEntity(Command):
 class UpdateEntityStatusAttributes(JsonMergePatchSemantics):
     """Attributes for the UpdateEntityStatus command."""
 
-    status: str = pydantic.Field(
-        description=Status.__fields__["status"].field_info.description
-    )
+    status: str = pydantic.Field(description=Status.model_fields["status"].description)
 
-    reason: Optional[Union[str, Null]] = pydantic.Field(
-        description=Status.__fields__["reason"].field_info.description
+    reason: Optional[str] = pydantic.Field(
+        description=Status.model_fields["reason"].description
     )
 
 

dyff/schema/v0/r1/dataset/arrow.py

@@ -13,6 +13,7 @@ from typing import Any, Iterable, Literal, Optional
 import pyarrow
 import pyarrow.dataset
 import pydantic
+from pydantic.fields import FieldInfo
 
 from ..base import DType
 from . import binary
@@ -31,7 +32,9 @@ def arrow_schema(
     We support a very basic subset of pydantic model features currently. The intention
     is to expand this.
     """
-    arrow_fields = [arrow_field(field) for _, field in model_type.__fields__.items()]
+    arrow_fields = [
+        arrow_field(name, field) for name, field in model_type.model_fields.items()
+    ]
     return pyarrow.schema(arrow_fields, metadata=metadata)
 
 
@@ -122,15 +125,37 @@ def arrow_type(annotation: type) -> pyarrow.DataType:
 
     if issubclass(annotation, pydantic.BaseModel):
         subfields = []
-        for _name, subfield in annotation.__fields__.items():
-            subfields.append(arrow_field(subfield))
+        for _name, subfield in annotation.model_fields.items():
+            subfields.append(arrow_field(_name, subfield))
         return pyarrow.struct(subfields)
 
-    # This doesn't get caught in the 'origin == list' case above because
-    # ConstrainedList isn't a generic type, but the desired result is the same
-    if issubclass(annotation, pydantic.ConstrainedList):
-        list_size = annotation.max_items if annotation.max_items is not None else -1
-        return pyarrow.list_(arrow_type(annotation.item_type), list_size)
+    # Handle numpy-like types
+    if hasattr(annotation, "dtype"):
+        return pyarrow.from_numpy_dtype(annotation.dtype)
+
+    # Handle Annotated list types (e.g., Annotated[list[str], Field(max_length=10)])
+    # This covers lists created by our list_() function in base.py which returns
+    # Annotated types with Field metadata for length constraints.
+    #
+    # We need custom logic here because:
+    # 1. Standard typing.List doesn't carry Pydantic Field constraints
+    # 2. Our list_() function wraps list[T] in Annotated[list[T], Field(...)]
+    #    to embed validation metadata (min/max length) at the type level
+    # 3. PyArrow needs to know these constraints upfront to create proper schemas
+    # 4. The nested generic structure requires careful extraction:
+    #    Annotated[list[str], Field(max_length=10)] needs to become
+    #    pyarrow.list_(pyarrow.string(), 10)
+    if (
+        typing.get_origin(annotation) is typing.Annotated
+        and typing.get_args(annotation)[0] is list
+    ):
+        metadata = typing.get_args(annotation)[1:]
+        item_type = typing.get_args(typing.get_args(annotation)[0])[0]
+        max_length = -1
+        for meta in metadata:
+            if isinstance(meta, FieldInfo):
+                max_length = getattr(meta, "max_length", -1)
+        return pyarrow.list_(arrow_type(item_type), max_length)
 
     if issubclass(annotation, DType):
         # The dtype is in the metaclass
@@ -138,7 +163,7 @@ def arrow_type(annotation: type) -> pyarrow.DataType:
 
     if annotation == bool:
         return pyarrow.bool_()
-    if annotation == bytes or issubclass(annotation, pydantic.ConstrainedBytes):
+    if annotation == bytes:
         return pyarrow.binary()
     if annotation == float:
         return pyarrow.float64()
@@ -147,13 +172,13 @@ def arrow_type(annotation: type) -> pyarrow.DataType:
     if annotation == uuid.UUID:
         return pyarrow.binary(16)
 
-    if annotation == str or issubclass(annotation, pydantic.ConstrainedStr):
+    if annotation == str:
         return pyarrow.string()
 
     raise NotImplementedError(f"Python type {annotation}")
 
 
-def arrow_field(pydantic_field: pydantic.fields.ModelField):
+def arrow_field(field_name: str, field_info: pydantic.fields.FieldInfo):
     """Create a named ``pyarrow.Field`` from a pydantic model ``ModelField``.
 
     If present, the ``.alias`` property of the ``ModelField`` takes precedence
@@ -161,10 +186,10 @@ def arrow_field(pydantic_field: pydantic.fields.ModelField):
     function. The ``.description`` property, if present, becomes the docstring
     for the arrow field.
     """
-    name = pydantic_field.alias if pydantic_field.has_alias else pydantic_field.name
-    docstring = pydantic_field.field_info.description
+    name = field_info.alias if field_info.alias else field_name
+    docstring = field_info.description
     return field_with_docstring(
-        name, arrow_type(pydantic_field.annotation), docstring=docstring
+        name, arrow_type(field_info.annotation or str), docstring=docstring
     )
 
 

dyff/schema/v0/r1/dataset/embedding.py

@@ -1,15 +1,22 @@
 # SPDX-FileCopyrightText: 2024 UL Research Institutes
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Type
+from typing import Type, Union
 
 import pydantic
+from typing_extensions import Annotated
 
-from ..base import DyffSchemaBaseModel, FixedWidthFloat, list_
+from ..base import DyffSchemaBaseModel, float32, float64, list_
 
 
 def embedding(
-    element_type: Type[FixedWidthFloat], size: int
+    element_type: Type[
+        Union[
+            Annotated[float, float32()],
+            Annotated[float, float64()],
+        ]
+    ],
+    size: int,
 ) -> Type[DyffSchemaBaseModel]:
     """Returns a schema type representing a list of fixed-length embedding vectors."""
 

dyff/schema/v0/r1/dataset/text.py

@@ -3,17 +3,21 @@
 
 import pydantic
 
-from ..base import DyffSchemaBaseModel, Int64
+from ..base import DyffSchemaBaseModel
 
 
 class TaggedSpan(DyffSchemaBaseModel):
     """A contiguous subsequence of text with a corresponding tag."""
 
-    start: Int64 = pydantic.Field(
-        description="The index of the first character in the span"
+    start: int = pydantic.Field(
+        description="The index of the first character in the span",
+        ge=0,  # Text indices should be non-negative
+        json_schema_extra={"dyff.io/dtype": "int64"},
     )
-    end: Int64 = pydantic.Field(
-        description="The index one past the final character in the span"
+    end: int = pydantic.Field(
+        description="The index one past the final character in the span",
+        ge=0,  # Text indices should be non-negative
+        json_schema_extra={"dyff.io/dtype": "int64"},
     )
     tag: str = pydantic.Field(description="The tag of the span")
 

dyff/schema/v0/r1/io/vllm.py

@@ -119,6 +119,6 @@ class GenerateEndpointOutput(DyffSchemaBaseModel):
     text: list[str] = pydantic.Field(
         # TODO: hypothesis plugin doesn't respect constraints
         # See: https://github.com/pydantic/pydantic/issues/2875
-        # min_items=1,
+        # min_length=1,
         description="List of generated responses. The prompt is prepended to each response.",
     )

dyff/schema/v0/r1/platform.py

@@ -28,7 +28,8 @@ from typing import Any, Literal, NamedTuple, Optional, Type, Union
 
 import pyarrow
 import pydantic
-from typing_extensions import TypeAlias
+from pydantic import StringConstraints
+from typing_extensions import Annotated, TypeAlias
 
 from ... import named_data_schema, product_schema
 from ...version import SomeSchemaVersion
@@ -283,7 +284,7 @@ EntityKindLiteral = Literal[
 ]
 
 
-EntityID: TypeAlias = pydantic.constr(regex=entity_id_regex())  # type: ignore
+EntityID: TypeAlias = Annotated[str, StringConstraints(pattern=entity_id_regex())]  # type: ignore
 
 
 class DyffModelWithID(DyffSchemaBaseModel):
@@ -306,21 +307,30 @@ class EntityIdentifier(DyffSchemaBaseModel):
 
 
 def LabelKey() -> type[str]:
-    return pydantic.constr(
-        regex=_k8s_label_key_regex(), max_length=_k8s_label_key_maxlen()
-    )
+    return Annotated[
+        str,
+        StringConstraints(
+            pattern=_k8s_label_key_regex(), max_length=_k8s_label_key_maxlen()
+        ),
+    ]  # type: ignore [return-value]
 
 
 def LabelValue() -> type[str]:
-    return pydantic.constr(  # type: ignore
-        regex=_k8s_label_value_regex(), max_length=_k8s_label_value_maxlen()
-    )
+    return Annotated[
+        str,
+        StringConstraints(
+            pattern=_k8s_label_value_regex(), max_length=_k8s_label_value_maxlen()
+        ),
+    ]  # type: ignore [return-value]
 
 
 def TagName() -> type[str]:
-    return pydantic.constr(  # type: ignore
-        regex=_oci_image_tag_regex(), max_length=_oci_image_tag_maxlen()
-    )
+    return Annotated[
+        str,
+        StringConstraints(
+            pattern=_oci_image_tag_regex(), max_length=_oci_image_tag_maxlen()
+        ),
+    ]  # type: ignore [return-value]
 
 
 LabelKeyType: TypeAlias = LabelKey()  # type: ignore
@@ -364,12 +374,14 @@ class Labeled(DyffSchemaBaseModel):
         " '.', '-', or '_'.\n\n"
         "We follow the kubernetes label conventions closely."
         " See: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels",
+        # Forbid entries that don't match the key patternProperties
+        json_schema_extra={"additionalProperties": False},
     )
 
 
 class Annotation(DyffSchemaBaseModel):
     key: str = pydantic.Field(
-        regex=_k8s_label_key_regex(),
+        pattern=_k8s_label_key_regex(),
         max_length=_k8s_domain_maxlen(),
         description="The annotation key. A DNS label with an optional DNS domain prefix."
         " For example: 'my-key', 'your.com/key_0'. Names prefixed with"
@@ -383,7 +395,7 @@ class Annotation(DyffSchemaBaseModel):
     )
 
 
-Quantity: TypeAlias = pydantic.constr(regex=_k8s_quantity_regex())  # type: ignore
+Quantity: TypeAlias = Annotated[str, StringConstraints(pattern=_k8s_quantity_regex())]  # type: ignore
 
 
 class ServiceClass(str, enum.Enum):
@@ -609,10 +621,10 @@ class AccessGrant(DyffSchemaBaseModel):
     """
 
     resources: list[Resources] = pydantic.Field(
-        min_items=1, description="List of resource types to which the grant applies"
+        min_length=1, description="List of resource types to which the grant applies"
     )
     functions: list[APIFunctions] = pydantic.Field(
-        min_items=1,
+        min_length=1,
         description="List of functions on those resources to which the grant applies",
     )
     accounts: list[str] = pydantic.Field(
@@ -700,7 +712,7 @@ class FamilyMemberBase(DyffSchemaBaseModel):
         description="ID of the resource this member references.",
     )
 
-    description: Optional[pydantic.constr(max_length=summary_maxlen())] = pydantic.Field(  # type: ignore
+    description: Optional[Annotated[str, StringConstraints(max_length=summary_maxlen())]] = pydantic.Field(  # type: ignore
         default=None,
         description="A short description of the member."
         " This should describe how this version of the resource"
@@ -719,7 +731,7 @@ class FamilyMember(FamilyMemberBase):
     )
 
     creationTime: datetime = pydantic.Field(
-        default=None, description="Tag creation time (assigned by system)"
+        description="Tag creation time (assigned by system)"
     )
 
 
@@ -916,12 +928,13 @@ class ExtractorStep(DyffSchemaBaseModel):
 
 class DyffDataSchema(DyffSchemaBaseModel):
     components: list[str] = pydantic.Field(
-        min_items=1,
+        min_length=1,
         description="A list of named dyff data schemas. The final schema is"
         " the composition of these component schemas.",
     )
     schemaVersion: SomeSchemaVersion = pydantic.Field(
-        default=SCHEMA_VERSION, description="The dyff schema version"
+        default=SCHEMA_VERSION,  # type: ignore [arg-type]
+        description="The dyff schema version",
     )
 
     def model_type(self) -> Type[DyffSchemaBaseModel]:
@@ -947,7 +960,7 @@ class DataSchema(DyffSchemaBaseModel):
     @staticmethod
     def from_model(model: Type[DyffSchemaBaseModel]) -> "DataSchema":
         arrowSchema = arrow.encode_schema(arrow.arrow_schema(model))
-        jsonSchema = model.schema()
+        jsonSchema = model.model_json_schema()
         return DataSchema(arrowSchema=arrowSchema, jsonSchema=jsonSchema)
 
     @staticmethod
@@ -966,14 +979,14 @@ class DataSchema(DyffSchemaBaseModel):
         elif isinstance(schema, DyffDataSchema):
             item_model = make_item_type(schema.model_type())
             arrowSchema = arrow.encode_schema(arrow.arrow_schema(item_model))
-            jsonSchema = item_model.schema()
+            jsonSchema = item_model.model_json_schema()
             return DataSchema(
                 arrowSchema=arrowSchema, dyffSchema=schema, jsonSchema=jsonSchema
             )
         else:
             item_model = make_item_type(schema)
             arrowSchema = arrow.encode_schema(arrow.arrow_schema(item_model))
-            jsonSchema = item_model.schema()
+            jsonSchema = item_model.model_json_schema()
             return DataSchema(arrowSchema=arrowSchema, jsonSchema=jsonSchema)
 
     @staticmethod
@@ -992,14 +1005,14 @@ class DataSchema(DyffSchemaBaseModel):
         elif isinstance(schema, DyffDataSchema):
             response_model = make_response_type(schema.model_type())
             arrowSchema = arrow.encode_schema(arrow.arrow_schema(response_model))
-            jsonSchema = response_model.schema()
+            jsonSchema = response_model.model_json_schema()
             return DataSchema(
                 arrowSchema=arrowSchema, dyffSchema=schema, jsonSchema=jsonSchema
             )
         else:
             response_model = make_response_type(schema)
             arrowSchema = arrow.encode_schema(arrow.arrow_schema(response_model))
-            jsonSchema = response_model.schema()
+            jsonSchema = response_model.model_json_schema()
             return DataSchema(arrowSchema=arrowSchema, jsonSchema=jsonSchema)
 
 
@@ -1030,7 +1043,7 @@ class DataView(DyffSchemaBaseModel):
 class DatasetBase(DyffSchemaBaseModel):
     name: str = pydantic.Field(description="The name of the Dataset")
     artifacts: list[Artifact] = pydantic.Field(
-        min_items=1, description="Artifacts that comprise the dataset"
+        min_length=1, description="Artifacts that comprise the dataset"
     )
     schema_: DataSchema = pydantic.Field(
         alias="schema", description="Schema of the dataset"
@@ -1108,7 +1121,7 @@ class ModelSource(DyffSchemaBaseModel):
 
 class AcceleratorGPU(DyffSchemaBaseModel):
     hardwareTypes: list[str] = pydantic.Field(
-        min_items=1,
+        min_length=1,
         description="Acceptable GPU hardware types.",
     )
     count: int = pydantic.Field(default=1, description="Number of GPUs required.")
@@ -1229,12 +1242,12 @@ class ContainerImageSource(DyffSchemaBaseModel):
     name: str = pydantic.Field(
         description="The name of the image",
         # https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pull
-        regex=r"^[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*(\/[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*)*$",
+        pattern=r"^[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*(\/[a-z0-9]+((\.|_|__|-+)[a-z0-9]+)*)*$",
     )
     digest: str = pydantic.Field(
         description="The digest of the image. The image is always pulled by"
         " digest, even if 'tag' is specified.",
-        regex=r"^sha256:[0-9a-f]{64}$",
+        pattern=r"^sha256:[0-9a-f]{64}$",
     )
     tag: Optional[TagNameType] = pydantic.Field(
         default=None,
@@ -1246,7 +1259,7 @@ class ContainerImageSource(DyffSchemaBaseModel):
     def url(self) -> str:
         return f"{self.host}/{self.name}@{self.digest}"
 
-    @pydantic.validator("host")
+    @pydantic.field_validator("host")
     def validate_host(cls, v: str):
         if "/" in v:
             raise ValueError(
@@ -1547,7 +1560,7 @@ class Evaluation(DyffEntity, EvaluationBase):
 class ModuleBase(DyffSchemaBaseModel):
     name: str = pydantic.Field(description="The name of the Module")
     artifacts: list[Artifact] = pydantic.Field(
-        min_items=1, description="Artifacts that comprise the Module implementation"
+        min_length=1, description="Artifacts that comprise the Module implementation"
     )
 
 
@@ -1629,7 +1642,7 @@ class MeasurementLevel(str, enum.Enum):
 
 
 class AnalysisOutputQueryFields(DyffSchemaBaseModel):
-    analysis: str = pydantic.Field(
+    analysis: Optional[str] = pydantic.Field(
         default=None,
         description="ID of the Analysis that produced the output.",
     )
@@ -1638,7 +1651,7 @@ class AnalysisOutputQueryFields(DyffSchemaBaseModel):
         description="Identifying information about the Method that was run to produce the output."
     )
 
-    inputs: list[str] = pydantic.Field(
+    inputs: Optional[list[str]] = pydantic.Field(
         default=None,
         description="IDs of resources that were inputs to the Analysis.",
     )
@@ -1781,7 +1794,7 @@ class ScoreSpec(DyffSchemaBaseModel):
     name: str = pydantic.Field(
         description="The name of the score. Used as a key for retrieving score data."
         " Must be unique within the Method context.",
-        regex=identifier_regex(),
+        pattern=identifier_regex(),
         max_length=identifier_maxlen(),
     )
 
@@ -1820,7 +1833,7 @@ class ScoreSpec(DyffSchemaBaseModel):
         default="{quantity:.1f}",
         # Must use the 'quantity' key in the format string:
         # (Maybe string not ending in '}')(something like '{quantity:f}')(maybe another string)
-        regex=r"^(.*[^{])?[{]quantity(:[^}]*)?[}]([^}].*)?$",
+        pattern=r"^(.*[^{])?[{]quantity(:[^}]*)?[}]([^}].*)?$",
         description="A Python 'format' string describing how to render the score"
         " as a string. You *must* use the keyword 'quantity' in the format"
         " string, and you may use 'unit' as well (e.g., '{quantity:.2f} {unit}')."
@@ -1839,15 +1852,15 @@ class ScoreSpec(DyffSchemaBaseModel):
         information stored in this ScoreSpec."""
         return self.format_quantity(self.format, quantity, unit=self.unit)
 
-    @pydantic.root_validator
+    @pydantic.model_validator(mode="after")
     def _validate_minimum_maximum(cls, values):
-        minimum = values.get("minimum")
-        maximum = values.get("maximum")
+        minimum = values.minimum
+        maximum = values.maximum
         if minimum is not None and maximum is not None and minimum > maximum:
             raise ValueError(f"minimum {minimum} is greater than maximum {maximum}")
         return values
 
-    @pydantic.validator("format")
+    @pydantic.field_validator("format")
     def _validate_format(cls, v):
         x = cls.format_quantity(v, 3.14, unit="kg")
         y = cls.format_quantity(v, -2.03, unit="kg")
@@ -1911,7 +1924,7 @@ class MethodBase(DyffSchemaBaseModel):
         " the default analysis environment.",
     )
 
-    @pydantic.validator("scores")
+    @pydantic.field_validator("scores")
     def _scores_validator(cls, scores: list[ScoreSpec]):
         if len(scores) > 0:
             primary_count = sum(score.priority == "primary" for score in scores)
@@ -2018,7 +2031,7 @@ class AnalysisData(DyffSchemaBaseModel):
     value: str = pydantic.Field(
         # Canonical base64 encoding
         # https://stackoverflow.com/a/64467300/3709935
-        regex=r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$",
+        pattern=r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/][AQgw]==|[A-Za-z0-9+/]{2}[AEIMQUYcgkosw048]=)?$",
         description="Arbitrary data encoded in base64.",
     )
 

dyff/schema/v0/r1/requests.py

@@ -22,7 +22,7 @@ import pydantic
 
 from ... import upcast
 from . import commands
-from .base import DyffBaseModel, JsonMergePatchSemantics, Null
+from .base import DyffBaseModel, JsonMergePatchSemantics
 from .platform import (
     AnalysisBase,
     AnalysisScope,
@@ -58,9 +58,9 @@ class DyffRequestDefaultValidators(DyffBaseModel):
     but we allow requests to have non-UTC timezones for user convenience.
     """
 
-    @pydantic.root_validator
+    @pydantic.model_validator(mode="after")
     def _require_datetime_timezone_aware(cls, values):
-        for k, v in values.items():
+        for k, v in values.__dict__.items():
             if isinstance(v, datetime):
                 if v.tzinfo is None:
                     raise ValueError(f"{cls.__qualname__}.{k}: timezone not set")
@@ -74,10 +74,14 @@ class DyffRequestBase(SchemaVersion, DyffRequestDefaultValidators):
     def dict(
         self, *, by_alias: bool = True, exclude_unset=True, **kwargs
     ) -> _ModelAsDict:
-        return super().dict(by_alias=by_alias, exclude_unset=exclude_unset, **kwargs)
+        return super().model_dump(
+            by_alias=by_alias, exclude_unset=exclude_unset, **kwargs
+        )
 
     def json(self, *, by_alias: bool = True, exclude_unset=True, **kwargs) -> str:
-        return super().json(by_alias=by_alias, exclude_unset=exclude_unset, **kwargs)
+        return super().model_dump_json(
+            by_alias=by_alias, exclude_unset=exclude_unset, **kwargs
+        )
 
 
 # ----------------------------------------------------------------------------
@@ -93,7 +97,7 @@ class AnalysisCreateRequest(DyffEntityCreateRequest, AnalysisBase):
 
     method: str = pydantic.Field(description="Method ID")
 
-    @pydantic.validator("scope", check_fields=False)
+    @pydantic.field_validator("scope", check_fields=False)
     def _validate_scope(cls, scope: AnalysisScope) -> AnalysisScope:
         # TODO: This has to be a validator function because we can't apply the
         # regex contraint to AnalysisScope, since there are already entities
@@ -114,7 +118,7 @@ class AnalysisCreateRequest(DyffEntityCreateRequest, AnalysisBase):
 
 
 class ConcernCreateRequest(DyffEntityCreateRequest, ConcernBase):
-    @pydantic.validator("documentation", check_fields=False)
+    @pydantic.field_validator("documentation", check_fields=False)
     def _validate_documentation(
         cls, documentation: DocumentationBase
     ) -> DocumentationBase:
@@ -148,7 +152,7 @@ class InferenceServiceCreateRequest(DyffEntityCreateRequest, InferenceServiceBas
     )
 
     # TODO: (DYFF-421) Make .image required and remove this validator
-    @pydantic.validator("image", check_fields=False)
+    @pydantic.field_validator("image", check_fields=False)
     def validate_image_not_none(cls, v):
         if v is None:
             raise ValueError(
@@ -189,10 +193,10 @@ class EvaluationCreateRequest(DyffEntityCreateRequest, EvaluationBase):
         " for the evaluation, instead of starting a new one.",
     )
 
-    @pydantic.root_validator
+    @pydantic.model_validator(mode="after")
     def check_session_exactly_one(cls, values):
-        session = values.get("inferenceSession") is not None
-        session_ref = values.get("inferenceSessionReference") is not None
+        session = values.inferenceSession is not None
+        session_ref = values.inferenceSessionReference is not None
         if not (session ^ session_ref):
             raise ValueError(
                 "must specify exactly one of {inferenceSession, inferenceSessionReference}"
@@ -208,16 +212,18 @@ class EvaluationCreateRequest(DyffEntityCreateRequest, EvaluationBase):
             return EvaluationCreateRequest(
                 account=evaluation.account,
                 inferenceSessionReference=evaluation.inferenceSessionReference,
-                **base.dict(),
+                **base.model_dump(),
             )
         else:
             return EvaluationCreateRequest(
                 account=evaluation.account,
                 inferenceSession=EvaluationInferenceSessionRequest(
                     inferenceService=evaluation.inferenceSession.inferenceService.id,
-                    **upcast(InferenceSessionBase, evaluation.inferenceSession).dict(),
+                    **upcast(
+                        InferenceSessionBase, evaluation.inferenceSession
+                    ).model_dump(),
                 ),
-                **base.dict(),
+                **base.model_dump(),
             )
 
 
@@ -268,10 +274,8 @@ class DocumentationEditRequest(
 
 
 class FamilyMembersEditRequest(DyffRequestBase, JsonMergePatchSemantics):
-    members: dict[TagNameType, Optional[Union[FamilyMemberBase, Null]]] = (
-        pydantic.Field(
-            description="Mapping of names to IDs of member resources.",
-        )
+    members: dict[TagNameType, Optional[FamilyMemberBase]] = pydantic.Field(
+        description="Mapping of names to IDs of member resources.",
     )
 
 

dyff/schema/v0/r1/version.py

@@ -10,7 +10,8 @@ SCHEMA_VERSION: str = "0.1"
 
 class SchemaVersion(pydantic.BaseModel):
     schemaVersion: Literal["0.1"] = pydantic.Field(
-        default=SCHEMA_VERSION, description="The schema version."
+        default=SCHEMA_VERSION,  # type: ignore [arg-type]
+        description="The schema version.",
     )