dyff-schema 0.28.0__py3-none-any.whl → 0.30.0__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

@@ -7,7 +7,6 @@ from __future__ import annotations
 import functools
 import inspect
 import typing
-import uuid
 from typing import Any, Iterable, Literal, Optional
 
 import pyarrow
@@ -31,7 +30,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)
 
 
@@ -89,12 +90,9 @@ def subset_schema(schema: pyarrow.Schema, field_names: list[str]) -> pyarrow.Sch
 
 
 def arrow_type(annotation: type) -> pyarrow.DataType:
-    """Determine a suitable arrow type for a pydantic model field.
+    """Determine a suitable arrow type for a pydantic model field."""
 
-    Supports primitive types as well as pydantic sub-models, lists, and optional types.
-    Numeric types must have appropriate bounds specified, as Arrow cannot represent the
-    unbounded integer types used by Python 3.
-    """
+    # Handle generic types first (List, Union, etc.)
     if origin := typing.get_origin(annotation):
         if origin == list:
             annotation_args = typing.get_args(annotation)
@@ -116,44 +114,45 @@ def arrow_type(annotation: type) -> pyarrow.DataType:
                 raise ValueError(
                     f"annotation {annotation}: only Optional[T] supported, not general Union"
                 )
-            return arrow_type(inner_type)  # All Arrow types are nullable
+            return arrow_type(inner_type)
 
         raise NotImplementedError(f"Python type {annotation}")
 
-    if issubclass(annotation, pydantic.BaseModel):
-        subfields = []
-        for _name, subfield in annotation.__fields__.items():
-            subfields.append(arrow_field(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)
+    # Guard against non-types (TypeVars, etc.)
+    if not isinstance(annotation, type):
+        return pyarrow.string()
 
+    # Handle custom types
     if issubclass(annotation, DType):
         # The dtype is in the metaclass
         return pyarrow.from_numpy_dtype(type(annotation).dtype)  # type: ignore[attr-defined]
 
-    if annotation == bool:
-        return pyarrow.bool_()
-    if annotation == bytes or issubclass(annotation, pydantic.ConstrainedBytes):
-        return pyarrow.binary()
-    if annotation == float:
-        return pyarrow.float64()
-    if annotation == int:
-        raise ValueError("unconstrained integers cannot be represented in Arrow")
-    if annotation == uuid.UUID:
-        return pyarrow.binary(16)
-
-    if annotation == str or issubclass(annotation, pydantic.ConstrainedStr):
-        return pyarrow.string()
+    # Handle numpy-like types
+    if hasattr(annotation, "dtype"):
+        return pyarrow.from_numpy_dtype(annotation.dtype)
+
+    # Handle pydantic models
+    if issubclass(annotation, pydantic.BaseModel):
+        subfields = []
+        for field_name, subfield in annotation.model_fields.items():
+            subfields.append(arrow_field(field_name, subfield))
+        return pyarrow.struct(subfields)
+
+    # Handle built-in types
+    type_map = {
+        str: pyarrow.string(),
+        int: pyarrow.int64(),
+        float: pyarrow.float64(),
+        bool: pyarrow.bool_(),
+    }
+
+    if annotation in type_map:
+        return type_map[annotation]
 
     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 +160,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")
@@ -1904,7 +1917,14 @@ class MethodBase(DyffSchemaBaseModel):
         description="Modules to load into the analysis environment",
     )
 
-    @pydantic.validator("scores")
+    analysisImage: Optional[ContainerImageSource] = pydantic.Field(
+        default=None,
+        description="Optional container image to use for running analysis methods."
+        " If specified, analysis will run in this custom container instead of"
+        " the default analysis environment.",
+    )
+
+    @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)
@@ -2011,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.",
     )