dyff-schema 0.2.2__py3-none-any.whl → 0.3.0__py3-none-any.whl

dyff/schema/ids.py

@@ -14,9 +14,9 @@ def generate_entity_id() -> str:
 
 
 def null_id() -> str:
-    """Return a special identifier signifying that the identity of an entity
-    is not important. Used for entities that are "owned" by another entity
-    that has a non-null identifier.
+    """Return a special identifier signifying that the identity of an entity is not
+    important. Used for entities that are "owned" by another entity that has a non-null
+    identifier.
 
     :returns: The null identifier -- a hex string representation of a UUID.
     :rtype: str
@@ -25,10 +25,9 @@ def null_id() -> str:
 
 
 def replication_id(evaluation_id: str, replication_index: int) -> str:
-    """Return a unique identifier for a replication within an evaluation.
-    Replications in different evaluations will have different identifiers, so
-    datasets from different evaluations can be combined without worrying about
-    collisions.
+    """Return a unique identifier for a replication within an evaluation. Replications
+    in different evaluations will have different identifiers, so datasets from different
+    evaluations can be combined without worrying about collisions.
 
     :param evaluation_id: The ID of the Evaluation.
     :type evaluation_id: str

dyff/schema/quantity.py

@@ -22,8 +22,7 @@ from typing import Any
 # See the License for the specific language governing permissions and
 # limitations under the License.
 def parse_quantity(quantity: Any) -> Decimal:
-    """Parse a kubernetes canonical form quantity like 200Mi to a decimal
-    number.
+    """Parse a kubernetes canonical form quantity like 200Mi to a decimal number.
 
     Supported SI suffixes:
     base1024: Ki | Mi | Gi | Ti | Pi | Ei

dyff/schema/v0/r1/adapters.py

@@ -15,10 +15,9 @@ from dyff.schema.platform import SchemaAdapter
 
 
 def map_structure(fn, data):
-    """Given a JSON data structure ``data``, create a new data structure
-    instance with the same shape as ``data`` by applying ``fn`` to each "leaf"
-    value in the nested data structure.
-    """
+    """Given a JSON data structure ``data``, create a new data structure instance with
+    the same shape as ``data`` by applying ``fn`` to each "leaf" value in the nested
+    data structure."""
     if isinstance(data, dict):
         return {k: map_structure(fn, v) for k, v in data.items()}
     elif isinstance(data, list):
@@ -30,10 +29,10 @@ def map_structure(fn, data):
 def flatten_object(
     obj: dict, *, max_depth: int | None = None, add_prefix: bool = True
 ) -> dict:
-    """Flatten a JSON object the by creating a new object with a key for
-    each "leaf" value in the input. If ``add_prefix`` is True, the key will be
-    equal to the "path" string of the leaf, i.e., "obj.field.subfield";
-    otherwise, it will be just "subfield".
+    """Flatten a JSON object the by creating a new object with a key for each "leaf"
+    value in the input. If ``add_prefix`` is True, the key will be equal to the "path"
+    string of the leaf, i.e., "obj.field.subfield"; otherwise, it will be just
+    "subfield".
 
     Nested lists are considered "leaf" values, even if they contain objects.
     """
@@ -72,8 +71,8 @@ class Adapter(Protocol):
 
 
 class TransformJSON:
-    """Transform an input JSON structure by creating a new output JSON
-    structure where all of the "leaf" values are populated by either:
+    """Transform an input JSON structure by creating a new output JSON structure where
+    all of the "leaf" values are populated by either:
 
         1. A provided JSON literal value, or
         2. The result of a jsonpath query on the input structure.
@@ -158,8 +157,8 @@ class TransformJSON:
 
 
 class EmbedIndex:
-    """Adds one or more fields to each member of the specified collections
-    that represent "indexes", or possible sort orders, for the collections.
+    """Adds one or more fields to each member of the specified collections that
+    represent "indexes", or possible sort orders, for the collections.
 
     For example, if the input data is::
 
@@ -232,11 +231,10 @@ class EmbedIndex:
 
 
 class ExplodeCollections:
-    """Explodes one or more top-level lists of the same length into multiple
-    records, where each record contains the corresponding value from each
-    list. This is useful for turning nested-list representations into
-    "relational" representations where the lists are converted to multiple
-    rows with a unique index.
+    """Explodes one or more top-level lists of the same length into multiple records,
+    where each record contains the corresponding value from each list. This is useful
+    for turning nested-list representations into "relational" representations where the
+    lists are converted to multiple rows with a unique index.
 
     The ``configuration`` argument is a dictionary::
 
@@ -341,8 +339,8 @@ class ExplodeCollections:
 
 
 class FlattenHierarchy:
-    """Flatten a JSON object -- or the JSON sub-objects in named fields -- by
-    creating a new object with a key for each "leaf" value in the input.
+    """Flatten a JSON object -- or the JSON sub-objects in named fields -- by creating a
+    new object with a key for each "leaf" value in the input.
 
     The ``configuration`` options are::
 
@@ -464,8 +462,8 @@ class Select:
 
 
 class Map:
-    """For each input item, map another Adapter over the elements of each of
-    the named nested collections within that item.
+    """For each input item, map another Adapter over the elements of each of the named
+    nested collections within that item.
 
     The configuration is a dictionary::
 

dyff/schema/v0/r1/base.py

@@ -147,7 +147,7 @@ class FixedWidthNumberMeta(
 
 
 class DType:
-    """Base class for pydantic custom types that have an Arrow .dtype"""
+    """Base class for pydantic custom types that have an Arrow .dtype."""
 
     @classmethod
     def __modify_schema__(
@@ -240,35 +240,35 @@ class UInt64Meta(FixedWidthNumberMeta[int, pydantic.ConstrainedInt]):
 
 
 class Int8(FixedWidthInt, metaclass=Int8Meta):
-    """An 8-bit integer"""
+    """An 8-bit integer."""
 
 
 class Int16(FixedWidthInt, metaclass=Int16Meta):
-    """A 16-bit integer"""
+    """A 16-bit integer."""
 
 
 class Int32(FixedWidthInt, metaclass=Int32Meta):
-    """A 32-bit integer"""
+    """A 32-bit integer."""
 
 
 class Int64(FixedWidthInt, metaclass=Int64Meta):
-    """A 64-bit integer"""
+    """A 64-bit integer."""
 
 
 class UInt8(FixedWidthInt, metaclass=UInt8Meta):
-    """An 8-bit unsigned integer"""
+    """An 8-bit unsigned integer."""
 
 
 class UInt16(FixedWidthInt, metaclass=UInt16Meta):
-    """A 16-bit unsigned integer"""
+    """A 16-bit unsigned integer."""
 
 
 class UInt32(FixedWidthInt, metaclass=UInt32Meta):
-    """A 32-bit unsigned integer"""
+    """A 32-bit unsigned integer."""
 
 
 class UInt64(FixedWidthInt, metaclass=UInt64Meta):
-    """A 64-bit unsigned integer"""
+    """A 64-bit unsigned integer."""
 
 
 # ----------------------------------------------------------------------------
@@ -557,11 +557,10 @@ def list_(
 class DyffSchemaBaseModel(pydantic.BaseModel):
     """Base class for pydantic models that used for defining data schemas.
 
-    Overrides serialization functions to serialize by alias, so that
-    "round-trip" serialization is the default for fields with aliases. We
-    prefer aliases because we can 1) use _underscore_names_ as reserved names
-    in our data schema, and 2) allow Python reserved words like 'bytes' as
-    field names.
+    Overrides serialization functions to serialize by alias, so that "round-trip"
+    serialization is the default for fields with aliases. We prefer aliases because we
+    can 1) use _underscore_names_ as reserved names in our data schema, and 2) allow
+    Python reserved words like 'bytes' as field names.
     """
 
     def dict(self, *, by_alias: bool = True, **kwargs) -> dict[str, Any]:

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

@@ -56,7 +56,8 @@ def make_item_type(schema: Type[DyffSchemaBaseModel]) -> Type[DyffSchemaBaseMode
 def make_response_item_type(
     schema: Type[DyffSchemaBaseModel],
 ) -> Type[DyffSchemaBaseModel]:
-    """Return a pydantic model type that inherits from both ``ResponseItem`` and ``schema``."""
+    """Return a pydantic model type that inherits from both ``ResponseItem`` and
+    ``schema``."""
     return pydantic.create_model(
         f"{schema.__name__}ResponseItem", __base__=(schema, ResponseItem)
     )

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

@@ -28,31 +28,28 @@ def arrow_schema(
 ) -> pyarrow.Schema:
     """Create an Arrow schema from a Pydantic model.
 
-    We support a very basic subset of pydantic model features currently. The
-    intention is to expand this.
+    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()]
     return pyarrow.schema(arrow_fields, metadata=metadata)
 
 
 def make_item_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra ``Item``
-    fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``Item`` fields
+    added."""
     return schema.insert(0, pyarrow.field("_index_", pyarrow.int64()))
 
 
 def make_response_item_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra
-    ``ResponseItem`` fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``ResponseItem``
+    fields added."""
     return schema.insert(0, pyarrow.field("_response_index_", pyarrow.int64()))
 
 
 def make_response_schema(schema: pyarrow.Schema) -> pyarrow.Schema:
-    """Given an Arrow schema, create a new one that has the extra
-    ``ResponseItem`` fields added.
-    """
+    """Given an Arrow schema, create a new one that has the extra ``ResponseItem``
+    fields added."""
     response_item_schema = make_response_item_schema(schema)
     fields = list(zip(response_item_schema.names, response_item_schema.types))
     item_type = pyarrow.struct(fields)
@@ -90,9 +87,9 @@ def subset_schema(schema: pyarrow.Schema, field_names: list[str]) -> pyarrow.Sch
 def arrow_type(annotation: type):
     """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.
+    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.
     """
     if origin := typing.get_origin(annotation):
         if origin == list:
@@ -176,9 +173,8 @@ def field_with_docstring(
     *,
     docstring: str | None = None,
 ) -> pyarrow.Field:
-    """Wrapper for ``pyarrow.field()`` that adds a docstring in the ``__doc__``
-    property of ``metadata``.
-    """
+    """Wrapper for ``pyarrow.field()`` that adds a docstring in the ``__doc__`` property
+    of ``metadata``."""
     if metadata:
         metadata_with_docstring = metadata.copy()
         if docstring:
@@ -192,9 +188,8 @@ def field_with_docstring(
 
 
 def schema_function(schema: pyarrow.Schema):
-    """Annotation for functions that return ``pyarrow.Schema``. The annotated
-    function will return the supplied schema and will have a docstring
-    describing the schema.
+    """Annotation for functions that return ``pyarrow.Schema``. The annotated function
+    will return the supplied schema and will have a docstring describing the schema.
 
     Intended to be applied to a function with no body, e.g.:
 

dyff/schema/v0/r1/platform.py

@@ -1,6 +1,5 @@
 # SPDX-FileCopyrightText: 2024 UL Research Institutes
 # SPDX-License-Identifier: Apache-2.0
-
 """Schema for the internal data representation of Dyff entities.
 
 We use the following naming convention:
@@ -42,9 +41,8 @@ def _k8s_quantity_regex():
 
 
 def _k8s_label_regex():
-    """A k8s label is like a DNS label but also allows ``.`` an ``_`` as
-    separator characters.
-    """
+    """A k8s label is like a DNS label but also allows ``.`` an ``_`` as separator
+    characters."""
     return r"[a-z0-9A-Z]([-_.a-z0-9A-Z]{0,61}[a-z0-9A-Z])?"
 
 
@@ -64,23 +62,26 @@ def _dns_label_maxlen():
 
 
 def _dns_domain_regex():
-    """One or more DNS labels separated by dots (``.``). Note that its maximum
-    length is 253 characters, but we can't enforce this in the regex.
+    """One or more DNS labels separated by dots (``.``).
+
+    Note that its maximum length is 253 characters, but we can't enforce this in the
+    regex.
     """
     return f"{_dns_label_regex()}(\.{_dns_label_regex()})*"
 
 
 def _k8s_domain_maxlen():
-    """Max length of a k8s domain. The DNS domain standard specifies 255
-    characters, but this includes the trailing dot and null terminator. We
-    never include a trailing dot in k8s-style domains.
+    """Max length of a k8s domain.
+
+    The DNS domain standard specifies 255 characters, but this includes the trailing dot
+    and null terminator. We never include a trailing dot in k8s-style domains.
     """
     return 253
 
 
 def _k8s_label_key_regex():
-    """The format of keys for labels and annotations. Optional subdomain prefix
-    followed by a k8s label.
+    """The format of keys for labels and annotations. Optional subdomain prefix followed
+    by a k8s label.
 
     See: https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/
 
@@ -151,6 +152,7 @@ class Entities(str, enum.Enum):
     """The kinds of entities in the dyff system."""
 
     Account = "Account"
+    Analysis = "Analysis"
     Audit = "Audit"
     AuditProcedure = "AuditProcedure"
     DataSource = "DataSource"
@@ -158,14 +160,18 @@ class Entities(str, enum.Enum):
     Evaluation = "Evaluation"
     InferenceService = "InferenceService"
     InferenceSession = "InferenceSession"
+    Measurement = "Measurement"
+    Method = "Method"
     Model = "Model"
     Module = "Module"
     Report = "Report"
+    SafetyCase = "SafetyCase"
 
 
 class Resources(str, enum.Enum):
     """The resource names corresponding to entities that have API endpoints."""
 
+    Analysis = "analyses"
     Audit = "audits"
     AuditProcedure = "auditprocedures"
     Dataset = "datasets"
@@ -173,9 +179,12 @@ class Resources(str, enum.Enum):
     Evaluation = "evaluations"
     InferenceService = "inferenceservices"
     InferenceSession = "inferencesessions"
+    Measurement = "measurements"
+    Method = "methods"
     Model = "models"
     Module = "modules"
     Report = "reports"
+    SafetyCase = "safetycases"
 
     Task = "tasks"
     """
@@ -189,30 +198,29 @@ class Resources(str, enum.Enum):
 
     @staticmethod
     def for_kind(kind: Entities) -> "Resources":
-        if kind == Entities.Audit:
-            return Resources.Audit
-        elif kind == Entities.AuditProcedure:
-            return Resources.AuditProcedure
-        elif kind == Entities.Dataset:
-            return Resources.Dataset
-        elif kind == Entities.DataSource:
-            return Resources.DataSource
-        elif kind == Entities.Evaluation:
-            return Resources.Evaluation
-        elif kind == Entities.InferenceService:
-            return Resources.InferenceService
-        elif kind == Entities.InferenceSession:
-            return Resources.InferenceSession
-        elif kind == Entities.Model:
-            return Resources.Model
-        elif kind == Entities.Module:
-            return Resources.Module
-        elif kind == Entities.Report:
-            return Resources.Report
-        else:
+        try:
+            return __entities_to_resources[kind]
+        except KeyError:
             raise ValueError(f"No Resources for Entity kind: {kind}")
 
 
+__entities_to_resources: dict[Entities, Resources] = {
+    Entities.Analysis: Resources.Analysis,
+    Entities.Audit: Resources.Audit,
+    Entities.AuditProcedure: Resources.AuditProcedure,
+    Entities.Dataset: Resources.Dataset,
+    Entities.DataSource: Resources.DataSource,
+    Entities.Evaluation: Resources.Evaluation,
+    Entities.InferenceService: Resources.InferenceService,
+    Entities.InferenceSession: Resources.InferenceSession,
+    Entities.Method: Resources.Method,
+    Entities.Model: Resources.Model,
+    Entities.Module: Resources.Module,
+    Entities.Report: Resources.Report,
+    Entities.SafetyCase: Resources.SafetyCase,
+}
+
+
 class DyffModelWithID(DyffSchemaBaseModel):
     id: str = pydantic.Field(description="Unique identifier of the entity")
     account: str = pydantic.Field(description="Account that owns the entity")
@@ -231,9 +239,9 @@ LabelValue: TypeAlias = Optional[  # type: ignore
 
 
 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 system.
+    """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
+    system.
 
     We follow the kubernetes label conventions closely. See:
     https://kubernetes.io/docs/concepts/overview/working-with-objects/labels
@@ -287,9 +295,7 @@ Quantity: TypeAlias = pydantic.constr(regex=_k8s_quantity_regex())  # type: igno
 
 
 class ServiceClass(str, enum.Enum):
-    """Defines the "quality of service" characteristics of a resource
-    allocation.
-    """
+    """Defines the "quality of service" characteristics of a resource allocation."""
 
     STANDARD = "standard"
     PREEMPTIBLE = "preemptible"
@@ -316,6 +322,7 @@ class Status(DyffSchemaBaseModel):
 
 class DyffEntity(Status, Labeled, Versioned, DyffModelWithID):
     kind: Literal[
+        "Analysis",
         "Audit",
         "AuditProcedure",
         "DataSource",
@@ -323,9 +330,12 @@ class DyffEntity(Status, Labeled, Versioned, DyffModelWithID):
         "Evaluation",
         "InferenceService",
         "InferenceSession",
+        "Measurement",
+        "Method",
         "Model",
         "Module",
         "Report",
+        "SafetyCase",
     ]
 
     annotations: list[Annotation] = pydantic.Field(
@@ -424,12 +434,11 @@ class APIFunctions(str, enum.Enum):
 
 
 class AccessGrant(DyffSchemaBaseModel):
-    """Grants access to call particular functions on particular instances of
-    particular resource types.
+    """Grants access to call particular functions on particular instances of particular
+    resource types.
 
-    Access grants are **additive**; the subject of a set of grants has
-    permission to do something if any part of any of those grants gives the
-    subject that permission.
+    Access grants are **additive**; the subject of a set of grants has permission to do
+    something if any part of any of those grants gives the subject that permission.
     """
 
     resources: list[Resources] = pydantic.Field(
@@ -450,11 +459,11 @@ class AccessGrant(DyffSchemaBaseModel):
 
 
 class APIKey(DyffSchemaBaseModel):
-    """A description of a set of permissions granted to a single subject
-    (either an account or a workload).
+    """A description of a set of permissions granted to a single subject (either an
+    account or a workload).
 
-    Dyff API clients authenticate with a *token* that contains a
-    cryptographically signed APIKey.
+    Dyff API clients authenticate with a *token* that contains a cryptographically
+    signed APIKey.
     """
 
     id: str = pydantic.Field(
@@ -543,9 +552,8 @@ class ArchiveFormat(DyffSchemaBaseModel):
 
 
 class ExtractorStep(DyffSchemaBaseModel):
-    """Description of a step in the process of turning a hierarchical
-    DataSource into a Dataset.
-    """
+    """Description of a step in the process of turning a hierarchical DataSource into a
+    Dataset."""
 
     action: str
     name: Optional[str] = None
@@ -843,8 +851,7 @@ class ModelSpec(ModelBase):
 
 class Model(DyffEntity, ModelSpec):
     """A Model is the "raw" form of an inference model, from which one or more
-    InferenceServices may be built.
-    """
+    InferenceServices may be built."""
 
     kind: Literal["Model"] = Entities.Model.value
 
@@ -975,9 +982,8 @@ class InferenceSessionSpec(InferenceSessionBase):
 
 
 class InferenceSession(DyffEntity, InferenceSessionSpec):
-    """An InferenceSession is a deployment of an InferenceService that exposes
-    an API for interactive queries.
-    """
+    """An InferenceSession is a deployment of an InferenceService that exposes an API
+    for interactive queries."""
 
     kind: Literal["InferenceSession"] = Entities.InferenceSession.value
 
@@ -1024,9 +1030,8 @@ class EvaluationBase(DyffSchemaBaseModel):
 
 
 class Evaluation(DyffEntity, EvaluationBase):
-    """A description of how to run an InferenceService on a Dataset to obtain
-    a set of evaluation results.
-    """
+    """A description of how to run an InferenceService on a Dataset to obtain a set of
+    evaluation results."""
 
     kind: Literal["Evaluation"] = Entities.Evaluation.value
 
@@ -1076,7 +1081,14 @@ class ReportBase(DyffSchemaBaseModel):
 
 
 class Report(DyffEntity, ReportBase):
-    """A Report transforms raw model outputs into some useful statistics."""
+    """A Report transforms raw model outputs into some useful statistics.
+
+    .. deprecated:: 0.8.0
+
+        Report functionality has been refactored into the
+        Method/Measurement/Analysis apparatus. Creation of new Reports is
+        disabled.
+    """
 
     kind: Literal["Report"] = Entities.Report.value
 
@@ -1102,7 +1114,277 @@ class Report(DyffEntity, ReportBase):
     )
 
     def dependencies(self) -> list[str]:
-        return [self.evaluation]
+        return [self.evaluation] + self.modules
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class QueryableDyffEntity(DyffModelWithID):
+    name: str = pydantic.Field(description="Descriptive name of the resource")
+
+
+class MeasurementLevel(str, enum.Enum):
+    Dataset = "Dataset"
+    Instance = "Instance"
+
+
+class AnalysisOutputQueryFields(DyffSchemaBaseModel):
+    method: QueryableDyffEntity = pydantic.Field(
+        description="Basic information about the Method that was run to produce the output."
+    )
+
+    dataset: Optional[QueryableDyffEntity] = pydantic.Field(
+        default=None,
+        description="Basic information about the Dataset being analyzed, if applicable.",
+    )
+
+    evaluation: Optional[QueryableDyffEntity] = pydantic.Field(
+        default=None,
+        description="Basic information about the Evaluation being analyzed, if applicable.",
+    )
+
+    inferenceService: Optional[QueryableDyffEntity] = pydantic.Field(
+        default=None,
+        description="Basic information about the InferenceService being analyzed, if applicable.",
+    )
+
+    model: Optional[QueryableDyffEntity] = pydantic.Field(
+        description="Basic information about the Model being analyzed, if applicable",
+    )
+
+
+class MeasurementSpec(DyffSchemaBaseModel):
+    name: str = pydantic.Field(description="Descriptive name of the Measurement.")
+    description: Optional[str] = pydantic.Field(
+        default=None, description="Long-form description, interpreted as Markdown."
+    )
+    level: MeasurementLevel = pydantic.Field(description="Measurement level")
+    schema_: DataSchema = pydantic.Field(
+        alias="schema",
+        description="Schema of the measurement data. Instance-level measurements must include an _index_ field.",
+    )
+
+
+class Measurement(DyffEntity, MeasurementSpec, AnalysisOutputQueryFields):
+    kind: Literal["Measurement"] = Entities.Measurement.value
+
+    def dependencies(self) -> list[str]:
+        return []
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class SafetyCaseSpec(DyffSchemaBaseModel):
+    name: str = pydantic.Field(description="Descriptive name of the SafetyCase.")
+    description: Optional[str] = pydantic.Field(
+        default=None, description="Long-form description, interpreted as Markdown."
+    )
+
+
+class SafetyCase(DyffEntity, SafetyCaseSpec, AnalysisOutputQueryFields):
+    kind: Literal["SafetyCase"] = Entities.SafetyCase.value
+
+    def dependencies(self) -> list[str]:
+        return []
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class MethodImplementationKind(str, enum.Enum):
+    JupyterNotebook = "JupyterNotebook"
+    PythonFunction = "PythonFunction"
+
+    PythonRubric = "PythonRubric"
+    """A Rubric generates an instance-level measurement, consuming a Dataset and an
+    Evaluation.
+
+    .. deprecated:: 0.8.0
+
+        Report functionality has been refactored into the
+        Method/Measurement/Analysis apparatus. Creation of new Reports is
+        disabled.
+    """
+
+
+class MethodImplementationJupyterNotebook(DyffSchemaBaseModel):
+    notebookModule: str = pydantic.Field(
+        description="ID of the Module that contains the notebook file."
+        " This does *not* add the Module as a dependency; you must do that separately."
+    )
+    notebookPath: str = pydantic.Field(
+        description="Path to the notebook file relative to the Module root directory."
+    )
+
+
+class MethodImplementationPythonFunction(DyffSchemaBaseModel):
+    fullyQualifiedName: str = pydantic.Field(
+        description="The fully-qualified name of the Python function to call."
+    )
+
+
+class MethodImplementationPythonRubric(DyffSchemaBaseModel):
+    """A Rubric generates an instance-level measurement, consuming a Dataset and an
+    Evaluation.
+
+    .. deprecated:: 0.8.0
+
+        Report functionality has been refactored into the
+        Method/Measurement/Analysis apparatus. Creation of new Reports is
+        disabled.
+    """
+
+    fullyQualifiedName: str = pydantic.Field(
+        description="The fully-qualified name of the Python Rubric to run."
+    )
+
+
+class MethodImplementation(DyffSchemaBaseModel):
+    kind: str = pydantic.Field(description="The kind of implementation")
+    pythonFunction: Optional[MethodImplementationPythonFunction] = pydantic.Field(
+        default=None, description="Specification of a Python function to call."
+    )
+    pythonRubric: Optional[MethodImplementationPythonRubric] = pydantic.Field(
+        default=None, description="@deprecated Specification of a Python Rubric to run."
+    )
+    jupyterNotebook: Optional[MethodImplementationJupyterNotebook] = pydantic.Field(
+        default=None, description="Specification of a Jupyter notebook to run."
+    )
+
+
+class MethodInputKind(str, enum.Enum):
+    Dataset = Entities.Dataset.value
+    Evaluation = Entities.Evaluation.value
+    Measurement = Entities.Measurement.value
+
+    Report = Entities.Report.value
+    """
+    .. deprecated:: 0.8.0
+
+        The Report entity is deprecated, but we accept it as an analysis input
+        for backward compatibility.
+    """
+
+
+class MethodOutputKind(str, enum.Enum):
+    Measurement = Entities.Measurement.value
+    SafetyCase = Entities.SafetyCase.value
+
+
+class MethodParameter(DyffSchemaBaseModel):
+    keyword: str = pydantic.Field(
+        description="The parameter is referred to by 'keyword' in the context of the method implementation."
+    )
+    description: Optional[str] = pydantic.Field(
+        default=None, description="Long-form description, interpreted as Markdown."
+    )
+
+
+class MethodInput(DyffSchemaBaseModel):
+    kind: MethodInputKind = pydantic.Field(description="The kind of input artifact.")
+    keyword: str = pydantic.Field(
+        description="The input is referred to by 'keyword' in the context of the method implementation."
+    )
+    description: Optional[str] = pydantic.Field(
+        default=None, description="Long-form description, interpreted as Markdown."
+    )
+
+
+class MethodOutput(DyffSchemaBaseModel):
+    kind: MethodOutputKind = pydantic.Field(description="The kind of output artifact")
+    measurement: Optional[MeasurementSpec] = pydantic.Field(
+        default=None, description="Specification of a Measurement output."
+    )
+    safetyCase: Optional[SafetyCaseSpec] = pydantic.Field(
+        default=None, description="Specification of a SafetyCase output."
+    )
+
+
+class MethodBase(DyffSchemaBaseModel):
+    name: str = pydantic.Field(description="Descriptive name of the Method.")
+
+    description: Optional[str] = pydantic.Field(
+        default=None, description="Long-form description, interpreted as Markdown."
+    )
+
+    implementation: MethodImplementation = pydantic.Field(
+        description="How the Method is implemented."
+    )
+
+    parameters: list[MethodParameter] = pydantic.Field(
+        default_factory=list,
+        description="Configuration parameters accepted by the Method. Values are available at ctx.args(keyword)",
+    )
+
+    inputs: list[MethodInput] = pydantic.Field(
+        default_factory=list,
+        description="Input data entities consumed by the Method. Available at ctx.inputs(keyword)",
+    )
+
+    output: MethodOutput = pydantic.Field(
+        description="Specification of the Method output."
+    )
+
+    modules: list[str] = pydantic.Field(
+        default_factory=list,
+        description="Modules to load into the analysis environment",
+    )
+
+
+class Method(DyffEntity, MethodBase):
+    kind: Literal["Method"] = Entities.Method.value
+
+    def dependencies(self) -> list[str]:
+        return self.modules
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class AnalysisInputMapping(DyffSchemaBaseModel):
+    keyword: str = pydantic.Field(
+        description="The 'keyword' specified for this input in the MethodSpec."
+    )
+    entity: str = pydantic.Field(
+        description="The ID of the entity whose data should be made available as 'keyword'."
+    )
+
+
+class AnalysisArgument(DyffSchemaBaseModel):
+    keyword: str = pydantic.Field(
+        description="The 'keyword' of the corresponding ModelParameter."
+    )
+    value: str = pydantic.Field(
+        description="The value of of the argument."
+        " Always a string; implementations are responsible for parsing."
+    )
+
+
+class ForeignMethod(DyffModelWithID, MethodBase):
+    pass
+
+
+class AnalysisBase(DyffSchemaBaseModel):
+    arguments: list[AnalysisArgument] = pydantic.Field(
+        description="Arguments to pass to the Method implementation."
+    )
+
+    inputs: list[AnalysisInputMapping] = pydantic.Field(
+        description="Mapping of keywords to data entities."
+    )
+
+
+class Analysis(DyffEntity, AnalysisBase):
+    kind: Literal["Analysis"] = Entities.Analysis.value
+
+    method: ForeignMethod = pydantic.Field(
+        description="The analysis Method to run.",
+    )
+
+    def dependencies(self) -> list[str]:
+        return [self.method.id] + [x.entity for x in self.inputs]
 
     def resource_allocation(self) -> Optional[ResourceAllocation]:
         return None
@@ -1113,9 +1395,8 @@ class Report(DyffEntity, ReportBase):
 
 
 class _JobStatus(NamedTuple):
-    """The set of basic ``status`` values that are applicable to all "job"
-    entities (entities that involve computation tasks).
-    """
+    """The set of basic ``status`` values that are applicable to all "job" entities
+    (entities that involve computation tasks)."""
 
     complete: str = "Complete"
     failed: str = "Failed"
@@ -1126,8 +1407,7 @@ JobStatus = _JobStatus()
 
 class _ResourceStatus(NamedTuple):
     """The set of basic ``status`` values that are applicable to all "resource"
-    entities.
-    """
+    entities."""
 
     ready: str = "Ready"
     error: str = "Error"
@@ -1283,7 +1563,8 @@ ModelStatusReason = _ModelStatusReason()
 
 
 class _InferenceServiceStatus(NamedTuple):
-    """The set of ``status`` values that are applicable to ``InferenceService`` entities."""
+    """The set of ``status`` values that are applicable to ``InferenceService``
+    entities."""
 
     created: str = EntityStatus.created
     admitted: str = EntityStatus.admitted
@@ -1295,7 +1576,8 @@ InferenceServiceStatus = _InferenceServiceStatus()
 
 
 class _InferenceServiceStatusReason(NamedTuple):
-    """The set of ``reason`` values that are applicable to ``InferenceService`` entities."""
+    """The set of ``reason`` values that are applicable to ``InferenceService``
+    entities."""
 
     quota_limit: str = EntityStatusReason.quota_limit
     build_failed: str = "BuildFailed"
@@ -1349,6 +1631,7 @@ def is_status_success(status: str) -> bool:
 
 
 _ENTITY_CLASS = {
+    Entities.Analysis: Analysis,
     Entities.Audit: Audit,
     Entities.AuditProcedure: AuditProcedure,
     Entities.Dataset: Dataset,
@@ -1356,9 +1639,12 @@ _ENTITY_CLASS = {
     Entities.Evaluation: Evaluation,
     Entities.InferenceService: InferenceService,
     Entities.InferenceSession: InferenceSession,
+    Entities.Measurement: Measurement,
+    Entities.Method: Method,
     Entities.Model: Model,
     Entities.Module: Module,
     Entities.Report: Report,
+    Entities.SafetyCase: SafetyCase,
 }
 
 
@@ -1367,6 +1653,7 @@ def entity_class(kind: Entities):
 
 
 DyffEntityType = Union[
+    Analysis,
     Audit,
     AuditProcedure,
     DataSource,
@@ -1374,9 +1661,12 @@ DyffEntityType = Union[
     Evaluation,
     InferenceService,
     InferenceSession,
+    Measurement,
+    Method,
     Model,
     Module,
     Report,
+    SafetyCase,
 ]
 
 
@@ -1384,6 +1674,11 @@ __all__ = [
     "Accelerator",
     "AcceleratorGPU",
     "AccessGrant",
+    "Analysis",
+    "AnalysisArgument",
+    "AnalysisBase",
+    "AnalysisInputMapping",
+    "AnalysisOutputQueryFields",
     "Annotation",
     "APIFunctions",
     "APIKey",
@@ -1427,6 +1722,21 @@ __all__ = [
     "LabelKey",
     "LabelValue",
     "Labeled",
+    "Measurement",
+    "MeasurementLevel",
+    "MeasurementSpec",
+    "Method",
+    "MethodBase",
+    "MethodImplementation",
+    "MethodImplementationJupyterNotebook",
+    "MethodImplementationKind",
+    "MethodImplementationPythonFunction",
+    "MethodImplementationPythonRubric",
+    "MethodInput",
+    "MethodInputKind",
+    "MethodOutput",
+    "MethodOutputKind",
+    "MethodParameter",
     "Model",
     "ModelArtifact",
     "ModelArtifactHuggingFaceCache",
@@ -1443,9 +1753,12 @@ __all__ = [
     "ModelStorage",
     "Module",
     "ModuleBase",
+    "QueryableDyffEntity",
     "Report",
     "ReportBase",
     "Resources",
+    "SafetyCase",
+    "SafetyCaseSpec",
     "SchemaAdapter",
     "Status",
     "StorageSignedURL",

dyff/schema/v0/r1/requests.py

@@ -1,9 +1,9 @@
 # SPDX-FileCopyrightText: 2024 UL Research Institutes
 # SPDX-License-Identifier: Apache-2.0
+"""The request schemas describe the information that you need to provide when creating
+new instances of the core types.
 
-"""
-The request schemas describe the information that you need to provide when
-creating new instances of the core types. For example, requests do not have
+For example, requests do not have
 ``.id`` fields because these are assigned by the platform when the resource
 is created. Similarly, if a resource depends on an instance of another
 resource, the request will refer to the dependency by its ID, while the core
@@ -19,12 +19,14 @@ import pydantic
 
 from .base import DyffSchemaBaseModel
 from .platform import (
+    AnalysisBase,
     DatasetBase,
     DataView,
     EvaluationBase,
     InferenceServiceBase,
     InferenceSessionBase,
     Labeled,
+    MethodBase,
     ModelSpec,
     ModuleBase,
     ReportBase,
@@ -36,6 +38,13 @@ class DyffEntityCreateRequest(Versioned, DyffSchemaBaseModel):
     account: str = pydantic.Field(description="Account that owns the entity")
 
 
+class AnalysisCreateRequest(DyffEntityCreateRequest, AnalysisBase):
+    """An Analysis transforms Datasets, Evaluations, and Measurements into new
+    Measurements or SafetyCases."""
+
+    method: str = pydantic.Field(description="Method ID")
+
+
 class DatasetCreateRequest(DyffEntityCreateRequest, DatasetBase):
     pass
 
@@ -59,21 +68,31 @@ class EvaluationInferenceSessionRequest(InferenceSessionBase):
 
 
 class EvaluationCreateRequest(DyffEntityCreateRequest, EvaluationBase):
-    """A description of how to run an InferenceService on a Dataset to obtain
-    a set of evaluation results.
-    """
+    """A description of how to run an InferenceService on a Dataset to obtain a set of
+    evaluation results."""
 
     inferenceSession: EvaluationInferenceSessionRequest = pydantic.Field(
         description="Specification of the InferenceSession that will perform inference for the evaluation.",
     )
 
 
+class MethodCreateRequest(DyffEntityCreateRequest, MethodBase):
+    pass
+
+
 class ModuleCreateRequest(DyffEntityCreateRequest, ModuleBase):
     pass
 
 
 class ReportCreateRequest(DyffEntityCreateRequest, ReportBase):
-    """A Report transforms raw model outputs into some useful statistics."""
+    """A Report transforms raw model outputs into some useful statistics.
+
+    .. deprecated:: 0.8.0
+
+        Report functionality has been refactored into the
+        Method/Measurement/Analysis apparatus. Creation of new Reports is
+        disabled.
+    """
 
     datasetView: Optional[Union[str, DataView]] = pydantic.Field(
         default=None,
@@ -111,6 +130,10 @@ class DyffEntityQueryRequest(DyffSchemaBaseModel):
         return super().json(exclude_unset=exclude_unset, **kwargs)
 
 
+class AnalysisQueryRequest(DyffEntityQueryRequest):
+    name: Optional[str] = pydantic.Field(default=None)
+
+
 class AuditQueryRequest(DyffEntityQueryRequest):
     name: Optional[str] = pydantic.Field(default=None)
 
@@ -141,6 +164,14 @@ class InferenceSessionQueryRequest(DyffEntityQueryRequest):
     modelName: Optional[str] = pydantic.Field(default=None)
 
 
+class MeasurementQueryRequest(DyffEntityQueryRequest):
+    dataset: Optional[str] = pydantic.Field(default=None)
+    inferenceService: Optional[str] = pydantic.Field(default=None)
+    inferenceServiceName: Optional[str] = pydantic.Field(default=None)
+    model: Optional[str] = pydantic.Field(default=None)
+    modelName: Optional[str] = pydantic.Field(default=None)
+
+
 class ModelQueryRequest(DyffEntityQueryRequest):
     name: Optional[str] = pydantic.Field(default=None)
 
@@ -158,6 +189,8 @@ class ReportQueryRequest(DyffEntityQueryRequest):
 
 
 __all__ = [
+    "AnalysisCreateRequest",
+    "AnalysisQueryRequest",
     "AuditQueryRequest",
     "DyffEntityCreateRequest",
     "DyffEntityQueryRequest",

dyff/schema/v0/r1/test.py

@@ -27,8 +27,10 @@ _OutputModelT = TypeVar("_OutputModelT", bound=DyffSchemaBaseModel)
 
 
 def forbid_additional_properties(schema: dict[str, Any]) -> dict[str, Any]:
-    """Create a modified JSON Schema where all elements of type ``object``
-    have ``additionalProperties = False`` set. This is useful when generating
+    """Create a modified JSON Schema where all elements of type ``object`` have
+    ``additionalProperties = False`` set.
+
+    This is useful when generating
     data conforming to the schema with the ``hypothesis`` package, since
     otherwise it will generate arbitrary extra fields.
     """
@@ -53,8 +55,8 @@ def pydantic_model_samples(
     *,
     acceptance_predicates: Optional[list[Callable[[_ModelT], bool]]] = None,
 ) -> list[_ModelT]:
-    """Sample a list of values that all conform to the schema defined by a
-    pydantic model.
+    """Sample a list of values that all conform to the schema defined by a pydantic
+    model.
 
     We use the ``hypothesis`` library to do the sampling. The sampling process
     tends to generate "extreme" values because the hypothesis library is meant
@@ -159,6 +161,9 @@ class MockDataset:
         else:
             raise NotImplementedError("sampling requires jsonSchema")
 
+        if self._data_schema.arrowSchema is None:
+            raise ValueError("data_schema.arrowSchema must be != None")
+
         if self._data_view and self._data_view.adapterPipeline:
             self._data_view_adapter = create_pipeline(self._data_view.adapterPipeline)
 
@@ -173,9 +178,8 @@ class MockDataset:
     def sample(self) -> dict[str, Any]:
         """Sample one item that conforms to the dataset schema, in JSON format.
 
-        Note that samples are drawn with replacement from a finite and fairly
-        small pool of candidates, so you should expect to get duplicate values
-        fairly often.
+        Note that samples are drawn with replacement from a finite and fairly small pool
+        of candidates, so you should expect to get duplicate values fairly often.
         """
         data = random.choice(self._data_schema_samples)
         if self._data_view_adapter:
@@ -194,6 +198,7 @@ class MockDataset:
     @functools.lru_cache()
     @copydoc(pyarrow.dataset.Dataset.schema)
     def schema(self) -> pyarrow.Schema:
+        assert self.data_schema.arrowSchema is not None  # safe; see __init__
         return arrow.decode_schema(self.data_schema.arrowSchema)
 
     @copydoc(pyarrow.dataset.Dataset.to_batches)

{dyff_schema-0.2.2.dist-info → dyff_schema-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dyff-schema
-Version: 0.2.2
+Version: 0.3.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.2.2.dist-info → dyff_schema-0.3.0.dist-info}/RECORD

@@ -2,10 +2,10 @@ dyff/schema/__init__.py,sha256=JcpxaRHNYgLjJWLjVayLlqacb2GX49Pazpwb8m-BctM,1031
 dyff/schema/adapters.py,sha256=YMTHv_2VlLGFp-Kqwa6H51hjffHmk8gXjZilHysIF5Q,123
 dyff/schema/base.py,sha256=jvaNtsSZyFfsdUZTcY_U-yfLY5_GyrMxSXhON2R9XR0,119
 dyff/schema/copydoc.py,sha256=B4ZRpQmbFxi-3l9LCHvaJiVKb9VxADgC5vey804Febc,1075
-dyff/schema/ids.py,sha256=MMaYOsmg2RQh0XskH9VA4GVTlBeuRrOIXCgHvrm5zFc,1426
+dyff/schema/ids.py,sha256=Z3JQzlAJQC2Pam7ehxb4TXA4MIuFQN5SyzL5Ql0RukA,1422
 dyff/schema/platform.py,sha256=peHzGGSd5dQ-EFXrWDjBqMUtoOL3iCHxcV3XzW6Rjag,123
 dyff/schema/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dyff/schema/quantity.py,sha256=q4yVF1p515wojZQhHi2mxxpXIpHDK9PThPWBm0gFK4Q,3792
+dyff/schema/quantity.py,sha256=hhS9ybqW_6I--acPhkoZbFWASxFTEs7CUjO4pmpBJ98,3788
 dyff/schema/requests.py,sha256=euObiC5IRe9fGev9ND--bcysuACNBDhSbZ5kONSaRwE,123
 dyff/schema/test.py,sha256=xtXZHqdVi_bjGXFFrd4nU10Y9CiukPyZj03rL84ckD4,119
 dyff/schema/version.py,sha256=MZhYsYOVmMuZo0R1vl1iSus7zfB8UerDcEgoZg7Ln7s,372
@@ -19,23 +19,23 @@ dyff/schema/io/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/io/vllm.py,sha256=2q05M_-lTzq9oywKXHPPpCFCSDVCSsRQqtmERzWTtio,123
 dyff/schema/v0/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/v0/r1/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
-dyff/schema/v0/r1/adapters.py,sha256=WB1L2vf17BPZmALReT4Iiio_M6EvpGU-Wa9zAHv1mao,23561
-dyff/schema/v0/r1/base.py,sha256=xVeguAoVzrNYt889uYQDlJrUHPUe2nBOhn7CMIV7Ah0,17134
-dyff/schema/v0/r1/platform.py,sha256=wRC62lF6FEJSKaB7vNgOYMrJeJ4eB4lKYNjBMfEq5hE,45090
-dyff/schema/v0/r1/requests.py,sha256=AKHr7mHyaz_heA6a66ogZx0RmfoOh9W5SKNsrYDERvA,6148
-dyff/schema/v0/r1/test.py,sha256=sSdKCgEONsGSolIPS8keQmNXsYUyNrJ2jHlX3y4JEj0,10522
+dyff/schema/v0/r1/adapters.py,sha256=2t2oxsnGfSEDKKDIEYw4qqLXMH7qlFIwPVuLyUmbsHs,23552
+dyff/schema/v0/r1/base.py,sha256=g_wqh4OU_9ftMHovVxPtdeup4O5MZi422v3eZH99ZQI,17139
+dyff/schema/v0/r1/platform.py,sha256=m2607uqLou3Q9vwN3yUqD694jPJSJINZXOM3fd0Ya-0,55236
+dyff/schema/v0/r1/requests.py,sha256=4xfHa8c53acDacZfUZt7TGYy1PaJRv08bwMWtU279UE,7213
+dyff/schema/v0/r1/test.py,sha256=X6dUyVd5svcPCI-PBMOAqEfK9jv3bRDvkQTJzwS96c0,10720
 dyff/schema/v0/r1/version.py,sha256=SG9ds8afHgdrqOA4CEY8-MM3lKfAE9G0rxsG4uyeglE,363
-dyff/schema/v0/r1/dataset/__init__.py,sha256=ZXO9SELqD1zxHGVwTe1iYfu3HZn9g4QkGY-mwWcdVsQ,2549
-dyff/schema/v0/r1/dataset/arrow.py,sha256=81Fqz8oS_67iclFUVr4iEQKZWHClW-LR-R6KAPPSWj0,12336
+dyff/schema/v0/r1/dataset/__init__.py,sha256=LbVlkO2asyGYBKk2z49xjJYTM-pu9y9e4eQDXgTDLnM,2553
+dyff/schema/v0/r1/dataset/arrow.py,sha256=juJ3MbiCL54zn3dSmXVl4GBhfLJPk6Qvasb0epFZ4V0,12312
 dyff/schema/v0/r1/dataset/binary.py,sha256=MLqj_O7iJvsDiom23jxR054seJaJntc0FTTkHuHYDJg,544
 dyff/schema/v0/r1/dataset/classification.py,sha256=pbbEXhxyZ0pgYwzaTlM8hVHPNEJDCdHKOeGowPXgWYc,311
 dyff/schema/v0/r1/dataset/text.py,sha256=nLIn91Zlt0tNdXUklSgjJ-kEDxoPX32ISLkiv2DzLvE,1008
 dyff/schema/v0/r1/dataset/vision.py,sha256=aIe0fbfM_g3DsrDTdg2K803YKLjZBpurM_VJcJFuZLc,369
 dyff/schema/v0/r1/io/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/v0/r1/io/vllm.py,sha256=CUE9y8KthtUI7sD49S875rDmPvKotSXVIRaBS79aBZs,5320
-dyff_schema-0.2.2.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dyff_schema-0.2.2.dist-info/METADATA,sha256=xjroREdO3IQVYc1297DKrHj2xpHSUN7_GoZHEon_VMo,3459
-dyff_schema-0.2.2.dist-info/NOTICE,sha256=YONACu0s_Ui6jNi-wtEsVQbTU1JIkh8wvLH6d1-Ni_w,43
-dyff_schema-0.2.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-dyff_schema-0.2.2.dist-info/top_level.txt,sha256=9e3VVdeX73t_sUJOPQPCcGtYO1JhoErhHIi3WoWGcFI,5
-dyff_schema-0.2.2.dist-info/RECORD,,
+dyff_schema-0.3.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dyff_schema-0.3.0.dist-info/METADATA,sha256=fU3lw7Kjf0ru9lz0PdNO0iBgjExSNL_7SNAntY9wJMQ,3459
+dyff_schema-0.3.0.dist-info/NOTICE,sha256=YONACu0s_Ui6jNi-wtEsVQbTU1JIkh8wvLH6d1-Ni_w,43
+dyff_schema-0.3.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+dyff_schema-0.3.0.dist-info/top_level.txt,sha256=9e3VVdeX73t_sUJOPQPCcGtYO1JhoErhHIi3WoWGcFI,5
+dyff_schema-0.3.0.dist-info/RECORD,,