dyff-schema 0.10.2__tar.gz → 0.11.0__tar.gz

{dyff_schema-0.10.2 → dyff_schema-0.11.0}/.gitlab-ci.yml

@@ -20,7 +20,7 @@ include:
     file:
       - prettier.yml
   - project: buildgarden/pipelines/python
-    ref: 0.12.0
+    ref: 0.13.0
     file:
       - python-autoflake.yml
       - python-black.yml
@@ -33,7 +33,7 @@ include:
       - python-twine-upload.yml
       - python-docformatter.yml
   - project: buildgarden/pipelines/skywalking-eyes
-    ref: 0.2.0
+    ref: 0.2.2
     file:
       - license-eye-header-check.yml
 

{dyff_schema-0.10.2/dyff_schema.egg-info → dyff_schema-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dyff-schema
-Version: 0.10.2
+Version: 0.11.0
 Summary: Data models for the Dyff AI auditing platform.
 Author-email: Digital Safety Research Institute <contact@dsri.org>
 License: Apache-2.0

dyff_schema-0.11.0/dyff/schema/annotations.py

@@ -0,0 +1,297 @@
+# SPDX-FileCopyrightText: 2024 UL Research Institutes
+# SPDX-License-Identifier: Apache-2.0
+
+# mypy: disable-error-code="import-untyped"
+import functools
+import typing
+from typing import Callable, Generic, Literal, NamedTuple, Optional, TypeVar
+
+import pyarrow.dataset
+import pydantic
+from typing_extensions import ParamSpec
+
+from dyff.schema.dataset import ReplicatedItem, arrow
+from dyff.schema.platform import (
+    DataSchema,
+    Dataset,
+    Evaluation,
+    Measurement,
+    MeasurementLevel,
+    MeasurementSpec,
+    MethodImplementation,
+    MethodImplementationKind,
+    MethodImplementationPythonFunction,
+    MethodInput,
+    MethodInputKind,
+    MethodOutput,
+    MethodOutputKind,
+    MethodParameter,
+    MethodScope,
+)
+from dyff.schema.requests import MethodCreateRequest
+
+
+def _fqn(obj) -> tuple[str, str]:
+    """See: https://stackoverflow.com/a/70693158"""
+    try:
+        module = obj.__module__
+    except AttributeError:
+        module = obj.__class__.__module__
+    try:
+        name = obj.__qualname__
+    except AttributeError:
+        name = obj.__class__.__qualname__
+    # if obj is a method of builtin class, then module will be None
+    if module == "builtins" or module is None:
+        raise AssertionError("should not be called on a builtin")
+    return module, name
+
+
+class DataAnnotation(NamedTuple):
+    kind: str
+    direction: Literal["input", "output"]
+    level: Optional[MeasurementLevel] = None
+    schema: Optional[DataSchema] = None
+
+
+def Input(input_type) -> DataAnnotation:
+    """Apply this annotation to parameters of a Method implementation to
+    indicate that the parameter expects a PyArrow dataset derived from the
+    specified type of entity, e.g.::
+
+        def my_method(input_data: Annotated[pyarrow.dataset.Dataset, Input(Evaluation)], ...
+
+    :param input_type: A Dyff entity type with associated input data; one of
+        {Dataset, Evaluation, Measurement}
+    :return: Annotation data
+    """
+    if input_type == Dataset:
+        return DataAnnotation(kind="Dataset", direction="input")
+    elif input_type == Evaluation:
+        return DataAnnotation(kind="Evaluation", direction="input")
+    elif input_type == Measurement:
+        return DataAnnotation(kind="Measurement", direction="input")
+    else:
+        raise TypeError()
+
+
+# TODO: I think this could work if we ever upgrade to Python 3.12+. We need the
+# type checker to accept `InputData[Evaluation]` and treat it as an alias for
+# `pyarrow.dataset.Dataset`.
+#
+# if typing.TYPE_CHECKING:
+#     _InputDataType = TypeVar("_InputDataType")
+#     type InputData[_InputDataType] = pyarrow.dataset.Dataset
+# else:
+#
+#     class InputData:
+#         def __init__(self):
+#             raise NotImplementedError()
+#
+#         def __class_getitem__(cls, input_type) -> typing.GenericAlias:
+#             return Annotated[pyarrow.dataset.Dataset, Input(input_type)]
+
+
+def Output(output_type, *, schema, level: Optional[MeasurementLevel] = None):
+    """Apply this annotation to the return type of a Method to provide
+    metadata about the type of output created by the Method, e.g.::
+
+        def my_method(...) -> Annotated[
+            Iterable[pyarrow.RecordBatch],
+            Output(Measurement, schema=MyPydanticType, level=MeasurementLevel.Instance)
+        ]: ...
+
+    :param output_type: A Dyff entity type with associated output data; one of
+        {Measurement, SafetyCase}
+    :param schema: The schema of the output. Can be a type derived from
+        pydantic.BaseModel or an Arrow schema. The mandatory fields `_index_`
+        and `_replication_` will be *added* and should not be present.
+    :param level: The MeasurementLevel, if the output is a Measurement.
+    :return: Annotation data
+    """
+    if isinstance(schema, type) and issubclass(schema, pydantic.BaseModel):
+        RowSchema = pydantic.create_model(
+            "RowSchema", __base__=(schema, ReplicatedItem)
+        )
+        data_schema = DataSchema(
+            arrowSchema=arrow.encode_schema(arrow.arrow_schema(RowSchema))
+        )
+    elif isinstance(schema, pyarrow.Schema):
+        raise NotImplementedError()
+        # TODO: Add _index_ and _replication_
+        # data_schema = DataSchema(arrowSchema=arrow.encode_schema(schema))
+    else:
+        raise TypeError()
+
+    if output_type == Measurement:
+        if level is None:
+            raise ValueError("Must specify 'level' when output_type == Measurement")
+        return DataAnnotation(
+            kind="Measurement",
+            direction="output",
+            level=level,
+            schema=data_schema,
+        )
+    else:
+        raise TypeError()
+
+
+# TODO: See comments about InputData above
+
+# _OutputDataType = TypeVar("_OutputDataType")
+# _OutputDataSchema = TypeVar("_OutputDataSchema")
+# _OutputDataLevel = TypeVar("_OutputDataLevel")
+
+
+# class OutputData(
+#     Generic[_OutputDataType, _OutputDataSchema, _OutputDataLevel],
+# ):
+#     def __init__(self):
+#         raise NotImplementedError()
+
+#     def __class_getitem__(cls, args) -> typing.GenericAlias:
+#         return Annotated[Iterable[pyarrow.RecordBatch], Output(*args)]
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+class MethodPrototype(Generic[P, R]):
+    """A wrapper for Python functions that implement Methods that knows how to create an
+    appropriate MethodCreateRequest based on the function signature."""
+
+    def __init__(
+        self,
+        f: Callable[P, R],
+        *,
+        scope: MethodScope,
+        description: Optional[str] = None,
+    ):
+        self.f = f
+        self.scope = scope
+        self.description = description
+        # This is similar to doing @functools.wraps() but it works with
+        # function objects
+        functools.update_wrapper(self, f)
+
+    def __call__(self, *args: P.args, **kwargs: P.kwargs) -> R:
+        return self.f(*args, **kwargs)
+
+    def create_request(
+        self, *, account: str, modules: list[str]
+    ) -> MethodCreateRequest:
+        """Create a MethodCreateRequest for the wrapped function.
+
+        :param account: The .account field for the request
+        :param modules: The .modules field for the request. This should include at least
+            the module that contains the wrapped function.
+        """
+        name = self.f.__name__
+        hints = typing.get_type_hints(self.f, include_extras=True)
+
+        parameters: list[MethodParameter] = []
+        inputs: list[MethodInput] = []
+        output: Optional[MethodOutput] = None
+        for k, v in hints.items():
+            annotation = None
+            if metadata := getattr(v, "__metadata__", None):
+                for m in metadata:
+                    if isinstance(m, DataAnnotation):
+                        annotation = m
+                        break
+            if k == "return":
+                if annotation is None:
+                    continue
+                if annotation.level is None:
+                    raise ValueError("Must specify .level for Output")
+                if annotation.schema is None:
+                    raise ValueError("Must specify .schema for Output")
+                output = MethodOutput(
+                    kind=MethodOutputKind(annotation.kind),
+                    measurement=MeasurementSpec(
+                        name=name,
+                        description=self.description,
+                        level=MeasurementLevel(annotation.level),
+                        schema=annotation.schema,
+                    ),
+                )
+            elif annotation is None:
+                parameters.append(MethodParameter(keyword=k))
+            else:
+                inputs.append(
+                    MethodInput(kind=MethodInputKind(annotation.kind), keyword=k)
+                )
+
+        if output is None:
+            raise TypeError("Return type must be annotated with Output()")
+
+        return MethodCreateRequest(
+            account=account,
+            modules=modules,
+            name=name,
+            scope=self.scope,
+            description=self.description,
+            implementation=MethodImplementation(
+                kind=MethodImplementationKind.PythonFunction,
+                pythonFunction=MethodImplementationPythonFunction(
+                    fullyQualifiedName=".".join(_fqn(self.f))
+                ),
+            ),
+            parameters=parameters,
+            inputs=inputs,
+            output=output,
+        )
+
+
+def method(
+    *, scope: MethodScope, description: Optional[str] = None
+) -> Callable[[Callable[P, R]], MethodPrototype[P, R]]:
+    """Use this decorator to indicate that a Python function implements a
+    Dyff Method. This should be used in conjunction with appropriate type
+    annotations, e.g.::
+
+        @method
+        def my_method(
+            arg: str,
+            data: Annotated[pyarrow.dataset.Dataset, Input(Evaluation)]
+        ) -> Annotated[
+            Iterable[pyarrow.RecordBatch],
+            Output(Measurement, schema=MyPydanticType, level=MeasurementLevel.Instance)
+        ]:
+            ...
+
+    The wrapped function will be an instance of MethodPrototype, and you can
+    use its .create_request() member function to create an appropriate
+    MethodCreateRequest for the wrapped function.
+
+    :param scope: The .scope field for the Method
+    :param description: The .description field for the Method. If not specified,
+        the docstring of the wrapped function will be used.
+    :return: A decorator that returns a MethodPrototype.
+    """
+
+    def decorator(f: Callable[P, R]) -> MethodPrototype[P, R]:
+        nonlocal description
+        if description is None:
+            description = f.__doc__
+        return MethodPrototype(f, scope=scope, description=description)
+
+    return decorator
+
+
+def method_request(
+    f: MethodPrototype, *, account: str, modules: list[str]
+) -> MethodCreateRequest:
+    return f.create_request(account=account, modules=modules)
+
+
+__all__ = [
+    "Input",
+    # "InputData",
+    "MethodPrototype",
+    "Output",
+    # "OutputData",
+    "method",
+    "method_request",
+]

{dyff_schema-0.10.2 → dyff_schema-0.11.0}/dyff/schema/v0/r1/base.py

@@ -558,11 +558,11 @@ def list_(
         return pydantic.conlist(item_type, min_items=list_size, max_items=list_size)
 
 
-# mypy gets confused because 'dict' is the name of a method in DyffDefaultSerializers
+# mypy gets confused because 'dict' is the name of a method in DyffBaseModel
 _ModelAsDict = dict[str, Any]
 
 
-class DyffDefaultSerializers(pydantic.BaseModel):
+class DyffBaseModel(pydantic.BaseModel):
     """This must be the base class for *all pydantic models* in the Dyff schema.
 
     Overrides serialization functions to serialize by alias, so that "round-trip"
@@ -571,6 +571,9 @@ class DyffDefaultSerializers(pydantic.BaseModel):
     Python reserved words like 'bytes' as field names.
     """
 
+    class Config:
+        extra = pydantic.Extra.forbid
+
     def dict(self, *, by_alias: bool = True, **kwargs) -> _ModelAsDict:
         return super().dict(by_alias=by_alias, **kwargs)
 
@@ -586,7 +589,7 @@ class DyffDefaultSerializers(pydantic.BaseModel):
     ) -> _ModelAsDict:
         """Encode the object as a dict containing only JSON datatypes.
 
-        .. deprecated::
+        .. deprecated:: 0.8.0
 
             FIXME: This emulates a Pydantic 2 feature, but the mode="json"
             option can only be implemented in an inefficient way. Remove when
@@ -603,10 +606,10 @@ class DyffDefaultSerializers(pydantic.BaseModel):
 # don't have timezones set currently for historical reasons. It's actually
 # better if all datetimes in the system are UTC, so that their JSON
 # representations (i.e., isoformat strings) are well-ordered.
-class DyffSchemaBaseModel(DyffDefaultSerializers):
+class DyffSchemaBaseModel(DyffBaseModel):
     """This should be the base class for *almost all* non-request models in the Dyff
     schema. Models that do not inherit from this class *must* still inherit from
-    DyffDefaultSerializers.
+    DyffBaseModel.
 
     Adds a root validator to ensure that all datetime fields are represented in the UTC
     timezone. This is necessary to avoid errors when comparing "naive" and "aware"
@@ -630,7 +633,7 @@ class DyffSchemaBaseModel(DyffDefaultSerializers):
 __all__ = [
     "DTYPE",
     "DType",
-    "DyffDefaultSerializers",
+    "DyffBaseModel",
     "DyffSchemaBaseModel",
     "FixedWidthFloat",
     "FixedWidthInt",

{dyff_schema-0.10.2 → dyff_schema-0.11.0}/dyff/schema/v0/r1/platform.py

@@ -140,6 +140,22 @@ def _k8s_label_value_maxlen():
     return _k8s_label_maxlen()
 
 
+def _oci_image_tag_regex():
+    """Regex matching valid image tags according to the OCI spec.
+
+    See: https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pull
+    """
+    return r"^[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}$"
+
+
+def _oci_image_tag_maxlen():
+    """Max length of valid image tags according to the OCI spec.
+
+    See: https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pull
+    """
+    return 127
+
+
 class Entities(str, enum.Enum):
     """The kinds of entities in the dyff system."""
 
@@ -149,8 +165,10 @@ class Entities(str, enum.Enum):
     AuditProcedure = "AuditProcedure"
     DataSource = "DataSource"
     Dataset = "Dataset"
+    Documentation = "Documentation"
     Evaluation = "Evaluation"
     Family = "Family"
+    History = "History"
     InferenceService = "InferenceService"
     InferenceSession = "InferenceSession"
     Measurement = "Measurement"
@@ -158,8 +176,8 @@ class Entities(str, enum.Enum):
     Model = "Model"
     Module = "Module"
     Report = "Report"
+    Revision = "Revision"
     SafetyCase = "SafetyCase"
-    Tag = "Tag"
 
 
 class Resources(str, enum.Enum):
@@ -170,8 +188,10 @@ class Resources(str, enum.Enum):
     AuditProcedure = "auditprocedures"
     Dataset = "datasets"
     DataSource = "datasources"
+    Documentation = "documentation"
     Evaluation = "evaluations"
     Family = "families"
+    History = "histories"
     InferenceService = "inferenceservices"
     InferenceSession = "inferencesessions"
     Measurement = "measurements"
@@ -179,8 +199,8 @@ class Resources(str, enum.Enum):
     Model = "models"
     Module = "modules"
     Report = "reports"
+    Revision = "revisions"
     SafetyCase = "safetycases"
-    Tag = "tags"
 
     Task = "tasks"
     """
@@ -217,6 +237,11 @@ LabelValue: TypeAlias = Optional[  # type: ignore
 ]
 
 
+TagName: TypeAlias = pydantic.constr(  # type: ignore
+    regex=_oci_image_tag_regex(), max_length=_k8s_label_key_maxlen()
+)
+
+
 class Label(DyffSchemaBaseModel):
     """A key-value label for a resource. Used to specify identifying attributes of
     resources that are meaningful to users but do not imply semantics in the dyff
@@ -331,67 +356,6 @@ class Documented(DyffSchemaBaseModel):
     )
 
 
-class FamilyMemberKind(str, enum.Enum):
-    """The kinds of entities that can be members of a Family.
-
-    These are resources for which it makes sense to have different versions or variants
-    that evolve over time.
-    """
-
-    Dataset = "Dataset"
-    InferenceService = "InferenceService"
-    Method = "Method"
-    Model = "Model"
-    Module = "Module"
-
-
-class FamilyMember(DyffSchemaBaseModel):
-    family: Optional[str] = pydantic.Field(
-        default=None,
-        description="ID of the Family to which the resource belongs.",
-    )
-
-
-class TagBase(DyffSchemaBaseModel):
-    tag: str = pydantic.Field(
-        description="An interpretable identifier for the tag that is unique in"
-        " the context of the corresponding Family."
-    )
-
-    resource: str = pydantic.Field(
-        description="ID of the resource this tag references.",
-    )
-
-    description: str = pydantic.Field(
-        description="A short description of the tag. Interpreted as Markdown."
-        " This should include information about how the tagged version is"
-        " different from other versions."
-    )
-
-
-class Tag(TagBase):
-    created: datetime = pydantic.Field(description="Tag creation time.")
-
-
-class Family(Labeled, SchemaVersion, DyffModelWithID):
-    kind: Literal["Family"] = "Family"
-
-    resourceKind: FamilyMemberKind = pydantic.Field(
-        description="The kind of resource that comprises the family.",
-    )
-
-    tags: list[Tag] = pydantic.Field(
-        default_factory=list,
-        description="Tags mapping interpretable names to resource IDs.",
-    )
-
-    documentation: DocumentationBase = pydantic.Field(
-        default_factory=DocumentationBase,
-        description="Documentation of the resource family. The content is used"
-        " to populate various views in the web UI.",
-    )
-
-
 class DyffEntity(Status, Labeled, SchemaVersion, DyffModelWithID):
     kind: Literal[
         "Analysis",
@@ -400,6 +364,8 @@ class DyffEntity(Status, Labeled, SchemaVersion, DyffModelWithID):
         "DataSource",
         "Dataset",
         "Evaluation",
+        "Family",
+        "History",
         "InferenceService",
         "InferenceSession",
         "Measurement",
@@ -407,6 +373,7 @@ class DyffEntity(Status, Labeled, SchemaVersion, DyffModelWithID):
         "Model",
         "Module",
         "Report",
+        "Revision",
         "SafetyCase",
     ]
 
@@ -584,6 +551,89 @@ class Account(DyffSchemaBaseModel):
     creationTime: Optional[datetime] = None
 
 
+class FamilyMemberKind(str, enum.Enum):
+    """The kinds of entities that can be members of a Family.
+
+    These are resources for which it makes sense to have different versions or variants
+    that evolve over time.
+    """
+
+    Dataset = "Dataset"
+    InferenceService = "InferenceService"
+    Method = "Method"
+    Model = "Model"
+    Module = "Module"
+
+
+class FamilyMemberBase(DyffSchemaBaseModel):
+    name: TagName = pydantic.Field(
+        description="An interpretable identifier for the member that is unique"
+        " in the context of the corresponding Family.",
+    )
+
+    resource: str = pydantic.Field(
+        description="ID of the resource this member references.",
+    )
+
+    description: Optional[str] = pydantic.Field(
+        default=None,
+        description="A short description of the member. Interpreted as Markdown."
+        " This should include information about how this version of the resource"
+        " is different from other versions.",
+    )
+
+
+class FamilyMember(FamilyMemberBase):
+    family: str = pydantic.Field(
+        description="Identifier of the Family containing this tag."
+    )
+
+    creationTime: datetime = pydantic.Field(
+        default=None, description="Tag creation time (assigned by system)"
+    )
+
+
+class FamilyMembers(DyffSchemaBaseModel):
+    members: dict[TagName, FamilyMember] = pydantic.Field(
+        default_factory=dict,
+        description="Mapping of names to IDs of member resources.",
+    )
+
+
+class FamilyBase(DyffSchemaBaseModel):
+    memberKind: FamilyMemberKind = pydantic.Field(
+        description="The kind of resource that comprises the family.",
+    )
+
+
+class Family(DyffEntity, FamilyBase, FamilyMembers):
+    kind: Literal["Family"] = "Family"
+
+    documentation: DocumentationBase = pydantic.Field(
+        default_factory=DocumentationBase,
+        description="Documentation of the resource family. The content is used"
+        " to populate various views in the web UI.",
+    )
+
+
+class RevisionMetadata(DyffSchemaBaseModel):
+    creationTime: datetime = pydantic.Field("The time when the Revision was created")
+
+
+# Note: The 'Revision' class itself is defined all the way at the end of this
+# file, because OpenAPI generation doesn't work with the Python < 3.10
+# "ForwardDeclaration" syntax.
+
+
+class History(DyffEntity):
+    kind: Literal["History"] = "History"
+
+    latest: str = pydantic.Field(description="The ID of the latest Revision")
+    revisions: dict[str, RevisionMetadata] = pydantic.Field(
+        description="The set of known Revisions"
+    )
+
+
 # ----------------------------------------------------------------------------
 
 
@@ -1011,13 +1061,11 @@ class ContainerImageSource(DyffSchemaBaseModel):
         " digest, even if 'tag' is specified.",
         regex=r"^sha256:[0-9a-f]{64}$",
     )
-    tag: Optional[str] = pydantic.Field(
+    tag: Optional[TagName] = pydantic.Field(
         default=None,
         description="The tag of the image. Although the image is always pulled"
         " by digest, including the tag is strongly recommended as it is often"
         " the main source of versioning information.",
-        # https://github.com/opencontainers/distribution-spec/blob/main/spec.md#pull
-        regex=r"^[a-zA-Z0-9_][a-zA-Z0-9._-]{0,127}$",
     )
 
     def url(self) -> str:
@@ -1908,12 +1956,14 @@ def entity_class(kind: Entities):
     return _ENTITY_CLASS[kind]
 
 
-DyffEntityType = Union[
+DyffEntityTypeExceptRevision = Union[
     Audit,
     AuditProcedure,
     DataSource,
     Dataset,
     Evaluation,
+    Family,
+    History,
     InferenceService,
     InferenceSession,
     Measurement,
@@ -1925,6 +1975,35 @@ DyffEntityType = Union[
 ]
 
 
+# Note: This class is defined here because OpenAPI generation doesn't work
+# with the Python < 3.10 "ForwardDeclaration" syntax. You get an error like:
+#
+# Traceback (most recent call last):
+#   File "/home/jessehostetler/dsri/code/dyff/dyff-api/./scripts/generate-openapi-definitions.py", line 15, in <module>
+#     get_openapi(
+#   File "/home/jessehostetler/dsri/code/dyff/venv/lib/python3.9/site-packages/fastapi/openapi/utils.py", line 422, in get_openapi
+#     definitions = get_model_definitions(
+#   File "/home/jessehostetler/dsri/code/dyff/venv/lib/python3.9/site-packages/fastapi/utils.py", line 60, in get_model_definitions
+#     m_schema, m_definitions, m_nested_models = model_process_schema(
+#   File "pydantic/schema.py", line 581, in pydantic.schema.model_process_schema
+#   File "pydantic/schema.py", line 622, in pydantic.schema.model_type_schema
+#   File "pydantic/schema.py", line 255, in pydantic.schema.field_schema
+#   File "pydantic/schema.py", line 527, in pydantic.schema.field_type_schema
+#   File "pydantic/schema.py", line 926, in pydantic.schema.field_singleton_schema
+#   File "/home/jessehostetler/.asdf/installs/python/3.9.18/lib/python3.9/abc.py", line 123, in __subclasscheck__
+#     return _abc_subclasscheck(cls, subclass)
+# TypeError: issubclass() arg 1 must be a class
+class Revision(DyffEntity, RevisionMetadata):
+    kind: Literal["Revision"] = "Revision"
+
+    entity: DyffEntityTypeExceptRevision = pydantic.Field(
+        description="The associated entity data",
+    )
+
+
+DyffEntityType = Union[DyffEntityTypeExceptRevision, Revision]
+
+
 __all__ = [
     "Accelerator",
     "AcceleratorGPU",
@@ -1965,12 +2044,16 @@ __all__ = [
     "EvaluationBase",
     "ExtractorStep",
     "Family",
+    "FamilyBase",
     "FamilyMember",
+    "FamilyMemberBase",
     "FamilyMemberKind",
+    "FamilyMembers",
     "ForeignInferenceService",
     "ForeignMethod",
     "ForeignModel",
     "Frameworks",
+    "History",
     "Identity",
     "InferenceInterface",
     "InferenceService",
@@ -2025,13 +2108,14 @@ __all__ = [
     "Report",
     "ReportBase",
     "Resources",
+    "Revision",
+    "RevisionMetadata",
     "SafetyCase",
     "SafetyCaseSpec",
     "SchemaAdapter",
     "Status",
     "StorageSignedURL",
-    "Tag",
-    "TagBase",
+    "TagName",
     "TaskSchema",
     "entity_class",
     "JobStatus",

{dyff_schema-0.10.2 → dyff_schema-0.11.0}/dyff/schema/v0/r1/requests.py

@@ -19,13 +19,15 @@ from typing import Optional, Union
 
 import pydantic
 
-from .base import DyffDefaultSerializers
+from .base import DyffBaseModel
 from .platform import (
     AnalysisBase,
     DatasetBase,
     DataView,
     DocumentationBase,
     EvaluationBase,
+    FamilyBase,
+    FamilyMembers,
     InferenceServiceBase,
     InferenceSessionBase,
     Labeled,
@@ -33,12 +35,11 @@ from .platform import (
     ModelSpec,
     ModuleBase,
     ReportBase,
-    TagBase,
 )
 from .version import SchemaVersion
 
 
-class DyffRequestDefaultValidators(DyffDefaultSerializers):
+class DyffRequestDefaultValidators(DyffBaseModel):
     """This must be the base class for *all* request models in the Dyff schema.
 
     Adds a root validator to ensure that all user-provided datetime fields have a
@@ -136,6 +137,10 @@ class EvaluationCreateRequest(DyffEntityCreateRequest, EvaluationBase):
         return values
 
 
+class FamilyCreateRequest(DyffEntityCreateRequest, FamilyBase):
+    pass
+
+
 class MethodCreateRequest(DyffEntityCreateRequest, MethodBase):
     pass
 
@@ -169,7 +174,7 @@ class ReportCreateRequest(DyffEntityCreateRequest, ReportBase):
     )
 
 
-class TagCreateRequest(DyffRequestBase, TagBase):
+class FamilyMembersEditRequest(DyffRequestBase, FamilyMembers):
     pass
 
 
@@ -226,6 +231,10 @@ class EvaluationQueryRequest(DyffEntityQueryRequest):
     modelName: Optional[str] = pydantic.Field(default=None)
 
 
+class FamilyQueryRequest(DyffEntityQueryRequest):
+    pass
+
+
 class InferenceServiceQueryRequest(DyffEntityQueryRequest):
     name: Optional[str] = pydantic.Field(default=None)
     model: Optional[str] = pydantic.Field(default=None)
@@ -282,6 +291,9 @@ __all__ = [
     "EvaluationCreateRequest",
     "EvaluationQueryRequest",
     "EvaluationInferenceSessionRequest",
+    "FamilyCreateRequest",
+    "FamilyMembersEditRequest",
+    "FamilyQueryRequest",
     "InferenceServiceCreateRequest",
     "InferenceServiceQueryRequest",
     "InferenceSessionCreateRequest",
@@ -298,5 +310,4 @@ __all__ = [
     "ReportCreateRequest",
     "ReportQueryRequest",
     "SafetyCaseQueryRequest",
-    "TagCreateRequest",
 ]

{dyff_schema-0.10.2 → dyff_schema-0.11.0/dyff_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dyff-schema
-Version: 0.10.2
+Version: 0.11.0
 Summary: Data models for the Dyff AI auditing platform.
 Author-email: Digital Safety Research Institute <contact@dsri.org>
 License: Apache-2.0

{dyff_schema-0.10.2 → dyff_schema-0.11.0}/dyff_schema.egg-info/SOURCES.txt

@@ -12,6 +12,7 @@ makefile
 pyproject.toml
 dyff/schema/__init__.py
 dyff/schema/adapters.py
+dyff/schema/annotations.py
 dyff/schema/base.py
 dyff/schema/copydoc.py
 dyff/schema/errors.py