dyff-schema 0.35.4__py3-none-any.whl → 0.36.0__py3-none-any.whl

dyff/schema/_version.py

@@ -1,2 +1,2 @@
-__version__ = version = "0.35.4"
-__version_tuple__ = version_tuple = (0, 35, 4)
+__version__ = version = "0.36.0"
+__version_tuple__ = version_tuple = (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/v0/r1/oci.py

@@ -53,18 +53,16 @@ class _OCISchemaBaseModel(pydantic.BaseModel):
         )
 
     @pydantic.model_validator(mode="after")
-    def _ensure_datetime_timezone_utc(cls, values):
-        for field_name, field_value in values.__dict__.items():
+    def _ensure_datetime_timezone_utc(self):
+        for field_name, field_value in self.__dict__.items():
             if isinstance(field_value, datetime):
                 if field_value.tzinfo is None:
                     # Set UTC timezone for naive datetime
-                    setattr(
-                        values, field_name, field_value.replace(tzinfo=timezone.utc)
-                    )
+                    setattr(self, field_name, field_value.replace(tzinfo=timezone.utc))
                 elif field_value.tzinfo != timezone.utc:
                     # Convert to UTC timezone
-                    setattr(values, field_name, field_value.astimezone(timezone.utc))
-        return values
+                    setattr(self, field_name, field_value.astimezone(timezone.utc))
+        return self
 
 
 class _DigestMixin(pydantic.BaseModel):

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",
     ]
 
@@ -730,7 +747,9 @@ class FamilyMemberBase(DyffSchemaBaseModel):
         description="ID of the resource this member references.",
     )
 
-    description: Optional[Annotated[str, StringConstraints(max_length=summary_maxlen())]] = pydantic.Field(  # type: ignore
+    description: Optional[
+        Annotated[str, StringConstraints(max_length=summary_maxlen())]
+    ] = pydantic.Field(  # type: ignore
         default=None,
         description="A short description of the member."
         " This should describe how this version of the resource"
@@ -2003,12 +2022,12 @@ class ScoreSpec(DyffSchemaBaseModel):
         return self.format_quantity(self.format, quantity, unit=self.unit)
 
     @pydantic.model_validator(mode="after")
-    def _validate_minimum_maximum(cls, values):
-        minimum = values.minimum
-        maximum = values.maximum
+    def _validate_minimum_maximum(self):
+        minimum = self.minimum
+        maximum = self.maximum
         if minimum is not None and maximum is not None and minimum > maximum:
             raise ValueError(f"minimum {minimum} is greater than maximum {maximum}")
-        return values
+        return self
 
     @pydantic.field_validator("format")
     def _validate_format(cls, v):
@@ -2292,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
 
@@ -2537,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,
@@ -2548,6 +2936,8 @@ _ENTITY_CLASS = {
     Entities.Module: Module,
     Entities.Report: Report,
     Entities.SafetyCase: SafetyCase,
+    Entities.Team: Team,
+    Entities.UseCase: UseCase,
 }
 
 
@@ -2558,6 +2948,7 @@ def entity_class(kind: Entities):
 _DyffEntityTypeRevisable = Union[
     Audit,
     AuditProcedure,
+    Challenge,
     DataSource,
     Dataset,
     Evaluation,
@@ -2572,6 +2963,7 @@ _DyffEntityTypeRevisable = Union[
     OCIArtifact,
     Report,
     SafetyCase,
+    Team,
     UseCase,
 ]
 
@@ -2649,6 +3041,12 @@ __all__ = [
     "Audit",
     "AuditProcedure",
     "AuditRequirement",
+    "Challenge",
+    "ChallengeContent",
+    "ChallengeContentPage",
+    "ChallengeSubmission",
+    "ChallengeTask",
+    "ChallengeTaskBase",
     "Concern",
     "ConcernBase",
     "Container",
@@ -2769,6 +3167,9 @@ __all__ = [
     "TagName",
     "TagNameType",
     "TaskSchema",
+    "Team",
+    "TeamMember",
+    "TeamAffiliation",
     "UseCase",
     "Volume",
     "VolumeMount",
@@ -2791,6 +3192,7 @@ __all__ = [
     "ModelStatusReason",
     "ReportStatus",
     "ReportStatusReason",
+    "body_maxlen",
     "identifier_regex",
     "identifier_maxlen",
     "is_status_terminal",

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,
@@ -60,12 +62,14 @@ class DyffRequestDefaultValidators(DyffBaseModel):
     """
 
     @pydantic.model_validator(mode="after")
-    def _require_datetime_timezone_aware(cls, values):
-        for k, v in values.__dict__.items():
+    def _require_datetime_timezone_aware(self):
+        for k, v in self.__dict__.items():
             if isinstance(v, datetime):
                 if v.tzinfo is None:
-                    raise ValueError(f"{cls.__qualname__}.{k}: timezone not set")
-        return values
+                    raise ValueError(
+                        f"{self.__class__.__qualname__}.{k}: timezone not set"
+                    )
+        return self
 
 
 class DyffRequestBase(SchemaVersion, DyffRequestDefaultValidators):
@@ -136,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(
@@ -171,14 +186,14 @@ class InferenceServiceCreateRequest(DyffEntityCreateRequest, InferenceServiceBas
     )
 
     @pydantic.model_validator(mode="after")
-    def check_runner_and_image_specified(cls, values):
-        if values.runner is None:
+    def check_runner_and_image_specified(self):
+        if self.runner is None:
             raise ValueError("must specify .runner in new inference services")
-        image = values.runner.image is not None
-        imageRef = values.runner.imageRef is not None
+        image = self.runner.image is not None
+        imageRef = self.runner.imageRef is not None
         if sum([image, imageRef]) != 1:
             raise ValueError("must specify exactly one of .runner.{image, imageRef}")
-        return values
+        return self
 
 
 class InferenceSessionCreateRequest(DyffEntityCreateRequest, InferenceSessionBase):
@@ -213,14 +228,14 @@ class EvaluationCreateRequest(DyffEntityCreateRequest, EvaluationBase):
     )
 
     @pydantic.model_validator(mode="after")
-    def check_session_exactly_one(cls, values):
-        session = values.inferenceSession is not None
-        session_ref = values.inferenceSessionReference is not None
+    def check_session_exactly_one(self):
+        session = self.inferenceSession is not None
+        session_ref = self.inferenceSessionReference is not None
         if not (session ^ session_ref):
             raise ValueError(
                 "must specify exactly one of {inferenceSession, inferenceSessionReference}"
             )
-        return values
+        return self
 
     @staticmethod
     def repeat_of(evaluation: Evaluation) -> EvaluationCreateRequest:
@@ -286,6 +301,10 @@ class ReportCreateRequest(DyffEntityCreateRequest, ReportBase):
 # ----------------------------------------------------------------------------
 
 
+class ChallengeContentEditRequest(DyffRequestBase, commands.EditChallengeContentPatch):
+    pass
+
+
 class DocumentationEditRequest(
     DyffRequestBase, commands.EditEntityDocumentationAttributes
 ):
@@ -471,6 +490,9 @@ __all__ = [
     "ArtifactCreateRequest",
     "ArtifactQueryRequest",
     "AuditQueryRequest",
+    "ChallengeContentEditRequest",
+    "ChallengeCreateRequest",
+    "ChallengeTaskCreateRequest",
     "ConcernCreateRequest",
     "DyffEntityCreateRequest",
     "DyffEntityQueryRequest",

{dyff_schema-0.35.4.dist-info → dyff_schema-0.36.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dyff-schema
-Version: 0.35.4
+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.4.dist-info → dyff_schema-0.36.0.dist-info}/RECORD

@@ -1,5 +1,5 @@
 dyff/schema/__init__.py,sha256=w7OWDFuyGKd6xt_yllNtKzHahPgywrfU4Ue02psYaMA,2244
-dyff/schema/_version.py,sha256=ex3qIUAM413mFfnfEYAcT0gprZTh1AbIC1kQnwFNARc,80
+dyff/schema/_version.py,sha256=WugzP-ohXoqseZsih5K8n5URp30AcEarRZlsq9obhyE,80
 dyff/schema/adapters.py,sha256=YMTHv_2VlLGFp-Kqwa6H51hjffHmk8gXjZilHysIF5Q,123
 dyff/schema/annotations.py,sha256=nE6Jk1PLqlShj8uqjE_EzZC9zYnTDW5AVtQcjysiK8M,10018
 dyff/schema/base.py,sha256=jvaNtsSZyFfsdUZTcY_U-yfLY5_GyrMxSXhON2R9XR0,119
@@ -27,10 +27,10 @@ dyff/schema/v0/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/v0/r1/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/v0/r1/adapters.py,sha256=hpwCSW8lkMkUKCLe0zaMUDu-VS_caSxJvPsECEi_XRA,33069
 dyff/schema/v0/r1/base.py,sha256=1VJXVLKldOq3aH2HdVgxXXk4DJTZEIiaTa4GzMKzziU,20228
-dyff/schema/v0/r1/commands.py,sha256=VoThKeIVz4ZQAqBXhb6TVOG6aG4m_Oa0_6Sc4oxyFhs,9801
-dyff/schema/v0/r1/oci.py,sha256=Jnnu2EBeYQKC-EbKLG60a5z3WwpOuZMogeJ7vQA74bM,6761
-dyff/schema/v0/r1/platform.py,sha256=MpgQ3_ookO8R2eJ6yXPXcZ7cFl82_YqV2LCrdlBoMAY,88563
-dyff/schema/v0/r1/requests.py,sha256=y1S0UDxXHUpM1fpFjVEUVXfiq6pnpIKBRypYNJFJsA0,18011
+dyff/schema/v0/r1/commands.py,sha256=mFKuPtRrk3Zr7Ce2snmqIG_vGIPCv-RTiXDo6BLILTU,17485
+dyff/schema/v0/r1/oci.py,sha256=YjHDVBJ2IIxqijll70OK6pM-qT6pq8tvU7D3YB9vGM0,6700
+dyff/schema/v0/r1/platform.py,sha256=UVDc4loKNQIw0J6PD_aDSGhxQLdorwz8lXwikhf-ORo,102071
+dyff/schema/v0/r1/requests.py,sha256=v9t8wg6ZYGCPp05HFtOnw093nCD9ED_lLOK__4Z2d4s,18584
 dyff/schema/v0/r1/responses.py,sha256=nxy7FPtfw2B_bljz5UGGuSE79HTkDQxKH56AJVmd4Qo,1287
 dyff/schema/v0/r1/test.py,sha256=X6dUyVd5svcPCI-PBMOAqEfK9jv3bRDvkQTJzwS96c0,10720
 dyff/schema/v0/r1/version.py,sha256=NONebgcv5Thsw_ymud6PacZdGjV6ndBrmLnap-obcpo,428
@@ -43,9 +43,9 @@ dyff/schema/v0/r1/dataset/text.py,sha256=MYG5seGODDryRSCy-g0Unh5dD0HCytmZ3FeElC-
 dyff/schema/v0/r1/dataset/vision.py,sha256=tJFF4dkhHX0UXTj1sPW-G22xTSI40gbYO465FuvmvAU,443
 dyff/schema/v0/r1/io/__init__.py,sha256=L5y8UhRnojerPYHumsxQJRcHCNz8Hj9NM8b47mewMNs,92
 dyff/schema/v0/r1/io/vllm.py,sha256=vWyLg-susbg0JDfv6VExBpgFdU2GHP2a14ChOdbckvs,5321
-dyff_schema-0.35.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-dyff_schema-0.35.4.dist-info/licenses/NOTICE,sha256=YONACu0s_Ui6jNi-wtEsVQbTU1JIkh8wvLH6d1-Ni_w,43
-dyff_schema-0.35.4.dist-info/METADATA,sha256=XzVBMfd4vbMGUC85Sim9XojnK8B17kQQfvvljXcrwQE,3668
-dyff_schema-0.35.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dyff_schema-0.35.4.dist-info/top_level.txt,sha256=9e3VVdeX73t_sUJOPQPCcGtYO1JhoErhHIi3WoWGcFI,5
-dyff_schema-0.35.4.dist-info/RECORD,,
+dyff_schema-0.36.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+dyff_schema-0.36.0.dist-info/licenses/NOTICE,sha256=YONACu0s_Ui6jNi-wtEsVQbTU1JIkh8wvLH6d1-Ni_w,43
+dyff_schema-0.36.0.dist-info/METADATA,sha256=kinDhGaP-46BDtS4QXZ6xFLgsCLhLjy66JnqDa3zdfk,3734
+dyff_schema-0.36.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dyff_schema-0.36.0.dist-info/top_level.txt,sha256=9e3VVdeX73t_sUJOPQPCcGtYO1JhoErhHIi3WoWGcFI,5
+dyff_schema-0.36.0.dist-info/RECORD,,