dyff-schema 0.35.5__tar.gz → 0.36.0__tar.gz

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v5.0.0
+    rev: v6.0.0
     hooks:
       - id: check-added-large-files
       - id: check-merge-conflict
@@ -23,12 +23,12 @@ repos:
           # - "--remove-all-unused-imports"
 
   - repo: https://github.com/psf/black
-    rev: 25.1.0
+    rev: 25.9.0
     hooks:
       - id: black
 
   - repo: https://github.com/PyCQA/isort
-    rev: "6.0.1"
+    rev: "6.1.0"
     hooks:
       - id: isort
 
@@ -40,25 +40,25 @@ repos:
         args: ["--in-place", "--black", "--config", "./pyproject.toml"]
 
   - repo: https://gitlab.com/saferatday0/library/skywalking-eyes
-    rev: "0.6.0"
+    rev: "0.8.3"
     hooks:
       - id: license-eye-header-fix
 
   - repo: https://gitlab.com/saferatday0/library/prettier
-    rev: 0.6.0
+    rev: 0.7.1
     hooks:
       - id: prettier
   - repo: https://gitlab.com/saferatday0/badgie
-    rev: "0.14.0"
+    rev: "0.14.2"
     hooks:
       - id: badgie
 
   - repo: https://gitlab.com/saferatday0/cici
-    rev: "0.9.3"
+    rev: "0.14.1"
     hooks:
       - id: cici-update
 
   - repo: https://gitlab.com/saferatday0/library/detect-secrets
-    rev: 0.6.0
+    rev: 0.7.2
     hooks:
       - id: detect-secrets

{dyff_schema-0.35.5/dyff_schema.egg-info → dyff_schema-0.36.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dyff-schema
-Version: 0.35.5
+Version: 0.36.0
 Summary: Data models for the Dyff AI auditing platform.
 Author-email: Digital Safety Research Institute <contact@dsri.org>
 License: Apache-2.0
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: canonicaljson==2.0.0
+Requires-Dist: email-validator
+Requires-Dist: google-i18n-address
 Requires-Dist: hypothesis
 Requires-Dist: hypothesis-jsonschema
 Requires-Dist: jsonpath-ng

dyff_schema-0.36.0/dyff/schema/_version.py

@@ -0,0 +1,2 @@
+__version__ = version = "0.36.0"
+__version_tuple__ = version_tuple = (0, 36, 0)

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/dyff/schema/v0/r1/commands.py

@@ -7,6 +7,7 @@ These are used internally by the platform and users typically won't encounter th
 
 from __future__ import annotations
 
+from datetime import datetime, timedelta, timezone
 from typing import Literal, Optional, Union
 
 import pydantic
@@ -15,6 +16,9 @@ from typing_extensions import Annotated
 
 from .base import DyffSchemaBaseModel, JsonMergePatchSemantics
 from .platform import (
+    ChallengeTask,
+    ChallengeTaskExecutionEnvironment,
+    ChallengeTaskSchedule,
     DyffEntityType,
     EntityIdentifier,
     FamilyMember,
@@ -24,6 +28,7 @@ from .platform import (
     SchemaVersion,
     Status,
     TagNameType,
+    body_maxlen,
     summary_maxlen,
     title_maxlen,
 )
@@ -42,7 +47,10 @@ class Command(SchemaVersion, DyffSchemaBaseModel):
     """
 
     command: Literal[
+        "CreateChallengeTask",
         "CreateEntity",
+        "EditChallengeContent",
+        "EditChallengeTaskRules",
         "EditEntityDocumentation",
         "EditEntityLabels",
         "EditFamilyMembers",
@@ -68,11 +76,220 @@ class CreateEntity(Command):
 # ----------------------------------------------------------------------------
 
 
+class CreateChallengeTaskAttributes(DyffSchemaBaseModel):
+    """Attributes for the CreateChallengeTask command."""
+
+    task: ChallengeTask = pydantic.Field(description="The task to create.")
+
+
+class CreateChallengeTaskData(EntityIdentifier):
+    """Payload data for the CreateChallengeTask command."""
+
+    attributes: CreateChallengeTaskAttributes = pydantic.Field(
+        description="The command attributes"
+    )
+
+
+class CreateChallengeTask(Command):
+    """Create a new challenge task within an existing challenge."""
+
+    command: Literal["CreateChallengeTask"] = "CreateChallengeTask"
+
+    data: CreateChallengeTaskData = pydantic.Field(description="The command data.")
+
+
+# ----------------------------------------------------------------------------
+
+
+class EditChallengeContentPagePatch(JsonMergePatchSemantics):
+    """Same properties as ChallengeContentPage.
+
+    Fields that are not assigned explicitly remain unchanged.
+    """
+
+    title: Annotated[str, StringConstraints(max_length=title_maxlen())] = (  # type: ignore
+        pydantic.Field(
+            default="",
+            description='A short plain string suitable as a title or "headline".',
+        )
+    )
+
+    summary: Annotated[str, StringConstraints(max_length=summary_maxlen())] = (  # type: ignore
+        pydantic.Field(
+            default="",
+            description="A brief summary, suitable for display in"
+            " small UI elements.",
+        )
+    )
+
+    body: Annotated[str, StringConstraints(max_length=body_maxlen())] = pydantic.Field(  # type: ignore
+        default="",
+        description="Long-form documentation. Interpreted as"
+        " Markdown. There are no length constraints, but be reasonable.",
+    )
+
+
+class EditChallengeContentPatch(DyffSchemaBaseModel):
+    page: EditChallengeContentPagePatch
+
+    @field_serializer("page")
+    def _serialize_page(self, page: EditChallengeContentPagePatch, _info):
+        return page.model_dump(mode=_info.mode)
+
+
+class EditChallengeContentAttributes(DyffSchemaBaseModel):
+    """Attributes for the EditChallengePageContent command."""
+
+    challenge: Optional[EditChallengeContentPatch] = pydantic.Field(
+        default=None,
+        description="Edits to make to the content of the main challenge page.",
+    )
+
+    tasks: Optional[dict[str, EditChallengeContentPatch]] = pydantic.Field(
+        default=None, description="Edits to make to the content of the challenge tasks."
+    )
+
+
+class EditChallengeContentData(EntityIdentifier):
+    """Payload data for the EditChallengePageContent command."""
+
+    attributes: EditChallengeContentAttributes = pydantic.Field(
+        description="The command attributes"
+    )
+
+
+class EditChallengeContent(Command):
+    """Edit the page content associated with a challenge-related entity.
+
+    Setting a documentation field to null/None deletes the corresponding value. To
+    preserve the existing value, leave the field *unset*.
+    """
+
+    command: Literal["EditChallengeContent"] = "EditChallengeContent"
+
+    data: EditChallengeContentData = pydantic.Field(description="The edit data.")
+
+
+# ----------------------------------------------------------------------------
+
+
+class EditChallengeTaskRulesExecutionEnvironmentChoices(JsonMergePatchSemantics):
+    """Same properties as ChallengeTaskExecutionEnvironmentChocies, but assigning None
+    to a field is interpreted as a command to delete that field.
+
+    Fields that are not assigned explicitly remain unchanged.
+    """
+
+    choices: dict[str, Optional[ChallengeTaskExecutionEnvironment]] = pydantic.Field(
+        default_factory=dict, description="Execution environment choices."
+    )
+    default: Optional[str] = pydantic.Field(
+        default=None, description="The default execution environment."
+    )
+
+
+class EditChallengeTaskRulesSchedule(JsonMergePatchSemantics):
+    """Same properties as ChallengeTaskSchedule, but assigning None to a field is
+    interpreted as a command to delete that field.
+
+    Fields that are not assigned explicitly remain unchanged.
+    """
+
+    openingTime: Optional[datetime] = pydantic.Field(
+        default=None, description="The announced opening time for task submissions."
+    )
+    closingTime: Optional[datetime] = pydantic.Field(
+        default=None, description="The announced closing time for task submissions."
+    )
+
+    submissionCycleDuration: timedelta = pydantic.Field(
+        default=timedelta(days=1),
+        description="The duration of a submission cycle."
+        " Teams are limited to a maximum number of submissions per cycle.",
+    )
+    submissionCycleEpoch: datetime = pydantic.Field(
+        default=datetime.fromtimestamp(0, timezone.utc),
+        description="The epoch of a submission cycle."
+        " For example, any given cycle lasts from"
+        " [epoch + N*duration, epoch + (N+1)*duration)."
+        " Teams are limited to a maximum number of submissions per cycle.",
+    )
+    submissionLimitPerCycle: int = pydantic.Field(
+        default=1,
+        ge=1,
+        description="Teams are limited to this many submissions per cycle.",
+    )
+
+
+class EditChallengeTaskRulesPatch(DyffSchemaBaseModel):
+    """Same properties as ChallengeTaskRules, but assigning None to a field is
+    interpreted as a command to delete that field.
+
+    Fields that are not assigned explicitly remain unchanged.
+    """
+
+    executionEnvironment: Optional[
+        EditChallengeTaskRulesExecutionEnvironmentChoices
+    ] = pydantic.Field(
+        default=None, description="Patch for the .rules.executionEnvironments field."
+    )
+    schedule: Optional[EditChallengeTaskRulesSchedule] = pydantic.Field(
+        default=None, description="Patch for the .rules.schedule field."
+    )
+
+    @field_serializer("executionEnvironment")
+    def _serialize_executionEnvironment(
+        self,
+        executionEnvironment: EditChallengeTaskRulesExecutionEnvironmentChoices,
+        _info,
+    ):
+        return executionEnvironment.model_dump(mode=_info.mode)
+
+    @field_serializer("schedule")
+    def _serialize_schedule(
+        self,
+        schedule: EditChallengeTaskRulesSchedule,
+        _info,
+    ):
+        return schedule.model_dump(mode=_info.mode)
+
+
+class EditChallengeTaskRulesAttributes(DyffSchemaBaseModel):
+    """Attributes for the EditChallengeTaskRules command."""
+
+    rules: EditChallengeTaskRulesPatch = pydantic.Field(
+        description="Edits to make to the task rules."
+    )
+
+
+class EditChallengeTaskRulesData(EntityIdentifier):
+    """Payload data for the EditChallengeTaskRules command."""
+
+    attributes: EditChallengeTaskRulesAttributes = pydantic.Field(
+        description="The command attributes"
+    )
+
+
+class EditChallengeTaskRules(Command):
+    """Edit the rules of a challenge task.
+
+    Setting a field to null/None deletes the corresponding value. To preserve the
+    existing value, leave the field *unset*.
+    """
+
+    command: Literal["EditChallengeTaskRules"] = "EditChallengeTaskRules"
+
+    data: EditChallengeTaskRulesData = pydantic.Field(description="The edit data.")
+
+
+# ----------------------------------------------------------------------------
+
+
 class EditEntityDocumentationPatch(JsonMergePatchSemantics):
     """Same properties as DocumentationBase, but assigning None to a field is
     interpreted as a command to delete that field.
 
-    Fields that are assigned explicitly remain unchanged.
+    Fields that are not assigned explicitly remain unchanged.
     """
 
     title: Optional[Annotated[str, StringConstraints(max_length=title_maxlen())]] = (  # type: ignore
@@ -292,7 +509,9 @@ class UpdateEntityStatus(Command):
 
 
 DyffCommandType = Union[
+    CreateChallengeTask,
     CreateEntity,
+    EditChallengeContent,
     EditEntityDocumentation,
     EditEntityLabels,
     EditFamilyMembers,
@@ -304,8 +523,16 @@ DyffCommandType = Union[
 
 __all__ = [
     "Command",
+    "CreateChallengeTask",
+    "CreateChallengeTaskAttributes",
+    "CreateChallengeTaskData",
     "CreateEntity",
     "DyffCommandType",
+    "EditChallengeContent",
+    "EditChallengeContentAttributes",
+    "EditChallengeContentData",
+    "EditChallengeContentPagePatch",
+    "EditChallengeContentPatch",
     "EditEntityDocumentation",
     "EditEntityDocumentationAttributes",
     "EditEntityDocumentationData",

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/dyff/schema/v0/r1/platform.py

@@ -22,11 +22,12 @@ We use the following naming convention:
 import abc
 import enum
 import urllib.parse
-from datetime import datetime
+from datetime import datetime, timedelta, timezone
 from enum import Enum
 from pathlib import Path
 from typing import Any, Literal, NamedTuple, Optional, Type, Union
 
+import i18naddress
 import pyarrow
 import pydantic
 from pydantic import StringConstraints
@@ -182,6 +183,10 @@ def summary_maxlen() -> int:
     return 280
 
 
+def body_maxlen() -> int:
+    return 1_000_000
+
+
 def entity_id_regex() -> str:
     """An entity ID is a 32-character HEX string.
 
@@ -199,6 +204,7 @@ class Entities(str, enum.Enum):
     Artifact = "OCIArtifact"
     Audit = "Audit"
     AuditProcedure = "AuditProcedure"
+    Challenge = "Challenge"
     Concern = "Concern"
     DataSource = "DataSource"
     Dataset = "Dataset"
@@ -217,6 +223,8 @@ class Entities(str, enum.Enum):
     Revision = "Revision"
     SafetyCase = "SafetyCase"
     Score = "Score"
+    Submission = "Submission"
+    Team = "Team"
     UseCase = "UseCase"
 
 
@@ -227,6 +235,7 @@ class Resources(str, enum.Enum):
     Artifact = "artifacts"
     Audit = "audits"
     AuditProcedure = "auditprocedures"
+    Challenge = "challenges"
     Concern = "concerns"
     Dataset = "datasets"
     DataSource = "datasources"
@@ -246,6 +255,8 @@ class Resources(str, enum.Enum):
     Revision = "revisions"
     SafetyCase = "safetycases"
     Score = "scores"
+    Submission = "submissions"
+    Team = "teams"
     UseCase = "usecases"
 
     Task = "tasks"
@@ -276,6 +287,7 @@ EntityKindLiteral = Literal[
     "Analysis",
     "Audit",
     "AuditProcedure",
+    "Challenge",
     "DataSource",
     "Dataset",
     "Evaluation",
@@ -293,6 +305,8 @@ EntityKindLiteral = Literal[
     "Report",
     "Revision",
     "SafetyCase",
+    "Submission",
+    "Team",
     "UseCase",
 ]
 
@@ -503,6 +517,7 @@ class DyffEntity(Status, Labeled, SchemaVersion, DyffModelWithID):
         "Analysis",
         "Audit",
         "AuditProcedure",
+        "Challenge",
         "DataSource",
         "Dataset",
         "Evaluation",
@@ -520,6 +535,8 @@ class DyffEntity(Status, Labeled, SchemaVersion, DyffModelWithID):
         "Report",
         "Revision",
         "SafetyCase",
+        "Submission",
+        "Team",
         "UseCase",
     ]
 
@@ -2294,6 +2311,372 @@ class OCIArtifact(DyffEntity):
         return None
 
 
+# ----------------------------------------------------------------------------
+# Challenges
+
+
+class ChallengeContentPage(DyffSchemaBaseModel):
+    """The content for the Web page corresponding to a challenge or challenge-related
+    object."""
+
+    title: str = pydantic.Field(
+        default="Untitled Challenge",
+        description='A short plain string suitable as a title or "headline".',
+        max_length=title_maxlen(),
+    )
+
+    summary: str = pydantic.Field(
+        default="",
+        description="A brief summary, suitable for display in small UI elements.",
+        max_length=summary_maxlen(),
+    )
+
+    body: str = pydantic.Field(
+        default="",
+        description="Long-form documentation. Interpreted as"
+        " Markdown and rendered as a single page. There are no length"
+        " constraints, but be reasonable.",
+        max_length=body_maxlen(),
+    )
+
+
+class ChallengeNewsItem(DyffSchemaBaseModel):
+    """A news item to display in the challenge news feed."""
+
+    id: str = pydantic.Field(description="Unique ID of the news item.")
+    title: str = pydantic.Field(
+        description='A short plain string suitable as a title or "headline".',
+        max_length=title_maxlen(),
+    )
+    summary: str = pydantic.Field(
+        description="A brief summary, suitable for display in small UI elements.",
+        max_length=summary_maxlen(),
+    )
+    postingTime: datetime = pydantic.Field(
+        description="The timestamp when the news item was posted."
+    )
+
+
+class TeamMember(DyffSchemaBaseModel):
+    """A member of a team."""
+
+    name: str = pydantic.Field(
+        description="The member's full name as it will be displayed in the UI."
+        " Include all desired titles and honorifics.",
+        max_length=title_maxlen(),
+    )
+    isCorrespondingMember: bool = pydantic.Field(
+        description="Indicates that this member will receive and respond to"
+        " correspondence pertaining to the team's participation in the challenge."
+        " At least one member must be a corresponding member."
+    )
+    email: Optional[pydantic.EmailStr] = pydantic.Field(
+        default=None, description="The member's email address."
+    )
+    orcid: Optional[str] = pydantic.Field(
+        default=None, description="The member's ORCID."
+    )
+    url: Optional[pydantic.HttpUrl] = pydantic.Field(
+        default=None,
+        description="The URL of the member's personal Web page or similar.",
+    )
+    note: Optional[str] = pydantic.Field(
+        default=None,
+        description="A brief note giving additional information about the member.",
+        max_length=summary_maxlen(),
+    )
+    affiliations: Optional[list[str]] = pydantic.Field(
+        default=None,
+        description="The member's affiliations, specified as keys in the"
+        " .affiliations dict in the corresonding Team object.",
+    )
+
+
+class GoogleI18nMailingAddress(DyffSchemaBaseModel):
+    """An international mailing address, in the schema used by Google's
+    i18n address metadata repository
+    (https://chromium-i18n.appspot.com/ssl-address) and as interpreted by the
+    Python ``google-i18n-address`` package.
+
+    The field names depart from our camelCase convention to match the
+    existing google-i18n-address format. We also use the empty string rather
+    than
+    """
+
+    street_address: str = pydantic.Field(
+        description="The (possibly multiline) street address.",
+    )
+    country_code: str = pydantic.Field(
+        description="Two-letter ISO 3166-1 country code.",
+    )
+    city: Optional[str] = pydantic.Field(
+        default=None,
+        description="A city or town name.",
+    )
+    country_area: Optional[str] = pydantic.Field(
+        default=None,
+        description="A designation of a region, province, or state.",
+    )
+    postal_code: Optional[str] = pydantic.Field(
+        default=None,
+        description="A postal code or zip code.",
+    )
+    sorting_code: Optional[str] = pydantic.Field(
+        default=None,
+        description="A sorting code.",
+    )
+    name: Optional[str] = pydantic.Field(
+        default=None,
+        description="A person's name.",
+    )
+    company_name: Optional[str] = pydantic.Field(
+        default=None,
+        description="A name of a company or organization.",
+    )
+
+    formatted: str = pydantic.Field(
+        default="",
+        description="The address formatted as a multi-line string (auto-generated).",
+    )
+
+    @pydantic.model_validator(mode="after")
+    def normalize_address(self):
+        """Normalizes the address and populates .formatted."""
+        unnormalized = self.model_dump()
+        normalized = i18naddress.normalize_address(unnormalized)
+        for k, v in normalized.items():
+            if v != "":
+                setattr(self, k, v)
+        self.formatted = i18naddress.format_address(normalized, latin=True)
+        return self
+
+
+class TeamAffiliation(DyffSchemaBaseModel):
+    """An organization with which one or more team members are affiliated, such as a
+    university or company."""
+
+    name: str = pydantic.Field(
+        description="The name of the organization as it will be displayed in the UI.",
+        max_length=title_maxlen(),
+    )
+    department: Optional[str] = pydantic.Field(
+        default=None,
+        description="A department within the organization.",
+        max_length=title_maxlen(),
+    )
+    group: Optional[str] = pydantic.Field(
+        default=None,
+        description="A group within the organization or department.",
+        max_length=title_maxlen(),
+    )
+
+    address: Optional[GoogleI18nMailingAddress] = pydantic.Field(
+        default=None,
+        description="The mailing address of the organization.",
+    )
+
+    url: Optional[pydantic.HttpUrl] = pydantic.Field(
+        default=None, description="The organization's Web page or similar."
+    )
+
+
+class Team(DyffEntity):
+    """The members and affiliations of a team that has entered a challenge."""
+
+    kind: Literal["Team"] = Entities.Team.value
+
+    challenge: str = pydantic.Field(
+        description="ID of the Challenge that this Team is participating in"
+    )
+    members: dict[str, TeamMember] = pydantic.Field(
+        description="The members of this team"
+    )
+    affiliations: dict[str, TeamAffiliation] = pydantic.Field(
+        description="The affiliations of the team. Team members state their"
+        " affiliations by referencing these entries by their keys."
+    )
+
+    def dependencies(self) -> list[str]:
+        return []
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class ChallengeTaskExecutionEnvironment(DyffSchemaBaseModel):
+    """Description of an execution environment that is available to run challenge
+    entries.
+
+    The specified computational resources are maximums; entries are free to request and
+    use fewer resources.
+    """
+
+    cpu: Quantity
+    memory: Quantity
+    accelerators: dict[str, int]
+
+
+class ChallengeTaskExecutionEnvironmentChoices(DyffSchemaBaseModel):
+    """The execution environment(s) available to run challenge entries.
+
+    For an InferenceService to be a valid submission for a Challenge, there must be at
+    least one execution environment defined for the challenge such that all of the
+    resource requests of the service are less than or equal to the corresponding limits
+    defined in the execution environment.
+    """
+
+    choices: dict[str, ChallengeTaskExecutionEnvironment]
+    default: str
+
+
+class ChallengeTaskSchedule(DyffSchemaBaseModel):
+    """The schedule of a challenge task."""
+
+    openingTime: Optional[datetime] = pydantic.Field(
+        default=None, description="The announced opening time for task submissions."
+    )
+    closingTime: Optional[datetime] = pydantic.Field(
+        default=None, description="The announced closing time for task submissions."
+    )
+    submissionCycleDuration: timedelta = pydantic.Field(
+        default=timedelta(days=1),
+        description="The duration of a submission cycle."
+        " Teams are limited to a maximum number of submissions per cycle.",
+    )
+    submissionCycleEpoch: datetime = pydantic.Field(
+        default=datetime.fromtimestamp(0, timezone.utc),
+        description="The epoch of a submission cycle."
+        " For example, any given cycle lasts from"
+        " [epoch + N*duration, epoch + (N+1)*duration)."
+        " Teams are limited to a maximum number of submissions per cycle.",
+    )
+    submissionLimitPerCycle: int = pydantic.Field(
+        default=1,
+        ge=1,
+        description="Teams are limited to this many submissions per cycle.",
+    )
+
+
+class ChallengeTaskRules(DyffSchemaBaseModel):
+    """The rules of the challenge."""
+
+    executionEnvironment: ChallengeTaskExecutionEnvironmentChoices = pydantic.Field(
+        description="The available choices for the execution environment."
+    )
+    schedule: ChallengeTaskSchedule = pydantic.Field(
+        description="The challenge schedule."
+    )
+
+
+class ChallengeTaskContent(DyffSchemaBaseModel):
+    """The content of a ChallengeTask UI view."."""
+
+    page: ChallengeContentPage = pydantic.Field(
+        description="The content of the challenge task Web page."
+    )
+
+
+class ChallengeTaskBase(DyffSchemaBaseModel):
+    """The part of the ChallengeTask spec that is not system-populated."""
+
+    challenge: str = pydantic.Field(
+        description="The ID of the Challenge of which this task is a member."
+    )
+    name: str = pydantic.Field(
+        description="Unique name for the task in the context of the challenge."
+        " This may appear in URLs and must follow naming restrictions.",
+        max_length=title_maxlen(),
+        pattern=r"[a-z0-9-]*",
+    )
+    assessment: str = pydantic.Field(
+        description="ID of the Assessment that the task runs."
+    )
+    rules: ChallengeTaskRules = pydantic.Field(description="The rules for submissions.")
+    content: ChallengeTaskContent = pydantic.Field(
+        description="Content of the task view in the Dyff App."
+    )
+
+
+class ChallengeTask(Status, ChallengeTaskBase, DyffModelWithID):
+    """A task that is part of a challenge.
+
+    Teams make submissions to individual tasks, rather than the overall challenge. A
+    task combines an assessment pipeline that actually implements the computations along
+    with rules for submissions and descriptive content for the Web app.
+    """
+
+    creationTime: datetime = pydantic.Field(
+        description="Resource creation time (assigned by system)"
+    )
+
+    lastTransitionTime: Optional[datetime] = pydantic.Field(
+        default=None, description="Time of last (status, reason) change."
+    )
+
+
+class ChallengeContent(DyffSchemaBaseModel):
+    """The content of a Challenge UI view."."""
+
+    page: ChallengeContentPage = pydantic.Field(
+        default_factory=ChallengeContentPage,
+        description="The content of the challenge Web page.",
+    )
+    news: dict[str, ChallengeNewsItem] = pydantic.Field(
+        default_factory=dict,
+        description="News items to display in the challenge news feed.",
+    )
+
+
+class Challenge(DyffEntity):
+    """A Challenge is a collection of assessments on which participating teams compete
+    to achieve the best performance."""
+
+    kind: Literal["Challenge"] = Entities.Challenge.value
+
+    content: ChallengeContent = pydantic.Field(
+        description="Content of the challenge view in the Dyff App."
+    )
+
+    tasks: dict[str, ChallengeTask] = pydantic.Field(
+        default_factory=dict, description="The assessments that comprise the challenge."
+    )
+
+    def dependencies(self) -> list[str]:
+        return []
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
+class ChallengeSubmission(DyffEntity):
+    """A submission of an inference system to a challenge by a team.
+
+    All of the constituent resources must already exist. Creating a Submission simply
+    indicates that the participating team wishes to submit the inference service as an
+    official entry. Most challenges will limit the number of submissions that can be
+    made in a given time interval.
+    """
+
+    kind: Literal["Submission"] = Entities.Submission.value
+
+    challenge: str = pydantic.Field(
+        description="The ID of the challenge being submitted to."
+    )
+    task: str = pydantic.Field(
+        description="The key of the task within the challenge being submitted to."
+    )
+    team: str = pydantic.Field(description="The ID of the team making the submission.")
+    inferenceService: str = pydantic.Field(
+        description="The ID of the inference service being submitted."
+    )
+
+    def dependencies(self) -> list[str]:
+        return []
+
+    def resource_allocation(self) -> Optional[ResourceAllocation]:
+        return None
+
+
 # ---------------------------------------------------------------------------
 # Status enumerations
 
@@ -2539,9 +2922,12 @@ _ENTITY_CLASS = {
     Entities.Artifact: OCIArtifact,
     Entities.Audit: Audit,
     Entities.AuditProcedure: AuditProcedure,
+    Entities.Challenge: Challenge,
     Entities.Dataset: Dataset,
     Entities.DataSource: DataSource,
     Entities.Evaluation: Evaluation,
+    Entities.Family: Family,
+    Entities.Hazard: Hazard,
     Entities.InferenceService: InferenceService,
     Entities.InferenceSession: InferenceSession,
     Entities.Measurement: Measurement,
@@ -2550,6 +2936,8 @@ _ENTITY_CLASS = {
     Entities.Module: Module,
     Entities.Report: Report,
     Entities.SafetyCase: SafetyCase,
+    Entities.Team: Team,
+    Entities.UseCase: UseCase,
 }
 
 
@@ -2560,6 +2948,7 @@ def entity_class(kind: Entities):
 _DyffEntityTypeRevisable = Union[
     Audit,
     AuditProcedure,
+    Challenge,
     DataSource,
     Dataset,
     Evaluation,
@@ -2574,6 +2963,7 @@ _DyffEntityTypeRevisable = Union[
     OCIArtifact,
     Report,
     SafetyCase,
+    Team,
     UseCase,
 ]
 
@@ -2651,6 +3041,12 @@ __all__ = [
     "Audit",
     "AuditProcedure",
     "AuditRequirement",
+    "Challenge",
+    "ChallengeContent",
+    "ChallengeContentPage",
+    "ChallengeSubmission",
+    "ChallengeTask",
+    "ChallengeTaskBase",
     "Concern",
     "ConcernBase",
     "Container",
@@ -2771,6 +3167,9 @@ __all__ = [
     "TagName",
     "TagNameType",
     "TaskSchema",
+    "Team",
+    "TeamMember",
+    "TeamAffiliation",
     "UseCase",
     "Volume",
     "VolumeMount",
@@ -2793,6 +3192,7 @@ __all__ = [
     "ModelStatusReason",
     "ReportStatus",
     "ReportStatusReason",
+    "body_maxlen",
     "identifier_regex",
     "identifier_maxlen",
     "is_status_terminal",

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/dyff/schema/v0/r1/requests.py

@@ -26,6 +26,8 @@ from .base import DyffBaseModel, JsonMergePatchSemantics
 from .platform import (
     AnalysisBase,
     AnalysisScope,
+    ChallengeContent,
+    ChallengeTaskBase,
     ConcernBase,
     DatasetBase,
     DataView,
@@ -138,6 +140,17 @@ class ArtifactCreateRequest(DyffEntityCreateRequest):
     pass
 
 
+class ChallengeCreateRequest(DyffEntityCreateRequest):
+    content: ChallengeContent = pydantic.Field(
+        default_factory=ChallengeContent,
+        description="Content of the challenge view in the Dyff App.",
+    )
+
+
+class ChallengeTaskCreateRequest(DyffEntityCreateRequest, ChallengeTaskBase):
+    pass
+
+
 class ConcernCreateRequest(DyffEntityCreateRequest, ConcernBase):
     @pydantic.field_validator("documentation", check_fields=False)
     def _validate_documentation(
@@ -288,6 +301,10 @@ class ReportCreateRequest(DyffEntityCreateRequest, ReportBase):
 # ----------------------------------------------------------------------------
 
 
+class ChallengeContentEditRequest(DyffRequestBase, commands.EditChallengeContentPatch):
+    pass
+
+
 class DocumentationEditRequest(
     DyffRequestBase, commands.EditEntityDocumentationAttributes
 ):
@@ -473,6 +490,9 @@ __all__ = [
     "ArtifactCreateRequest",
     "ArtifactQueryRequest",
     "AuditQueryRequest",
+    "ChallengeContentEditRequest",
+    "ChallengeCreateRequest",
+    "ChallengeTaskCreateRequest",
     "ConcernCreateRequest",
     "DyffEntityCreateRequest",
     "DyffEntityQueryRequest",

{dyff_schema-0.35.5 → dyff_schema-0.36.0/dyff_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dyff-schema
-Version: 0.35.5
+Version: 0.36.0
 Summary: Data models for the Dyff AI auditing platform.
 Author-email: Digital Safety Research Institute <contact@dsri.org>
 License: Apache-2.0
@@ -21,6 +21,8 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 License-File: NOTICE
 Requires-Dist: canonicaljson==2.0.0
+Requires-Dist: email-validator
+Requires-Dist: google-i18n-address
 Requires-Dist: hypothesis
 Requires-Dist: hypothesis-jsonschema
 Requires-Dist: jsonpath-ng

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/dyff_schema.egg-info/requires.txt

@@ -1,4 +1,6 @@
 canonicaljson==2.0.0
+email-validator
+google-i18n-address
 hypothesis
 hypothesis-jsonschema
 jsonpath-ng

{dyff_schema-0.35.5 → dyff_schema-0.36.0}/pyproject.toml

@@ -31,6 +31,8 @@ classifiers=[
 
 dependencies = [
     "canonicaljson==2.0.0",
+    "email-validator",
+    "google-i18n-address",
     "hypothesis",
     "hypothesis-jsonschema",
     "jsonpath-ng",

dyff_schema-0.35.5/dyff/schema/_version.py

@@ -1,2 +0,0 @@
-__version__ = version = "0.35.5"
-__version_tuple__ = version_tuple = (0, 35, 5)