docket-client 0.3.2__py3-none-any.whl

docket/models/acquisition_warning.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="AcquisitionWarning")
+
+
+@_attrs_define
+class AcquisitionWarning:
+    """A non-blocking notice attached to a create or edit response. Warnings never
+    reject the write.
+
+        Attributes:
+            code (str): Machine-readable kind; currently only `instrument_overlap`.
+            message (str): Human-readable explanation.
+            acquisition_id (int): The other acquisition involved.
+            subject_id (str): Subject of the other acquisition.
+            scheduled_start (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+            scheduled_end (datetime.datetime | None):
+    """
+
+    code: str
+    message: str
+    acquisition_id: int
+    subject_id: str
+    scheduled_start: datetime.datetime
+    scheduled_end: datetime.datetime | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        code = self.code
+
+        message = self.message
+
+        acquisition_id = self.acquisition_id
+
+        subject_id = self.subject_id
+
+        scheduled_start = self.scheduled_start.isoformat()
+
+        scheduled_end: None | str
+        if isinstance(self.scheduled_end, datetime.datetime):
+            scheduled_end = self.scheduled_end.isoformat()
+        else:
+            scheduled_end = self.scheduled_end
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "message": message,
+                "acquisition_id": acquisition_id,
+                "subject_id": subject_id,
+                "scheduled_start": scheduled_start,
+                "scheduled_end": scheduled_end,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        message = d.pop("message")
+
+        acquisition_id = d.pop("acquisition_id")
+
+        subject_id = d.pop("subject_id")
+
+        scheduled_start = datetime.datetime.fromisoformat(d.pop("scheduled_start"))
+
+        def _parse_scheduled_end(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_instant_nullable_type_1 = datetime.datetime.fromisoformat(data)
+
+                return componentsschemas_instant_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        scheduled_end = _parse_scheduled_end(d.pop("scheduled_end"))
+
+        acquisition_warning = cls(
+            code=code,
+            message=message,
+            acquisition_id=acquisition_id,
+            subject_id=subject_id,
+            scheduled_start=scheduled_start,
+            scheduled_end=scheduled_end,
+        )
+
+        acquisition_warning.additional_properties = d
+        return acquisition_warning
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

docket/models/add_principal_request.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.principal_kind import PrincipalKind
+
+
+T = TypeVar("T", bound="AddPrincipalRequest")
+
+
+@_attrs_define
+class AddPrincipalRequest:
+    """Registers a principal before it has signed in (how rig applications are added).
+
+    Attributes:
+        object_id (str): Directory object id (a GUID) of the person or the application's service principal.
+        kind (PrincipalKind): What kind of directory principal a role is held by.
+        display_name (str): A label for the list.
+    """
+
+    object_id: str
+    kind: PrincipalKind
+    display_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        object_id = self.object_id
+
+        kind = self.kind.value
+
+        display_name = self.display_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object_id": object_id,
+                "kind": kind,
+                "display_name": display_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        object_id = d.pop("object_id")
+
+        kind = PrincipalKind(d.pop("kind"))
+
+        display_name = d.pop("display_name")
+
+        add_principal_request = cls(
+            object_id=object_id,
+            kind=kind,
+            display_name=display_name,
+        )
+
+        add_principal_request.additional_properties = d
+        return add_principal_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

docket/models/api_token_response.py

@@ -0,0 +1,271 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.access_role_nullable_type_1 import AccessRoleNullableType1
+from ..models.access_role_nullable_type_2_type_1 import AccessRoleNullableType2Type1
+from ..models.access_role_nullable_type_3_type_1 import AccessRoleNullableType3Type1
+from ..models.api_token_status import ApiTokenStatus
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="ApiTokenResponse")
+
+
+@_attrs_define
+class ApiTokenResponse:
+    """An API token's metadata. The secret is shown once, when created, and never again.
+
+    Attributes:
+        id (int): Token id; also recorded in the audit as `api_token:<id>`.
+        principal_object_id (str): The principal the token acts as: it gets exactly that principal's roles.
+        name (str): What the token is for.
+        prefix (str): First 8 characters of the token (e.g. `dkt_ab12`), to recognize it.
+        created_by_object_id (None | str): The admin who issued it. An admin can issue a token for any registered
+            person, and it then acts as that person; this makes it visible.
+        created_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        expires_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        last_used_at (datetime.datetime | None):
+        revoked_at (datetime.datetime | None):
+        status (ApiTokenStatus): Whether an API token can be used.
+        personal (bool | Unset): True when the owner created it themselves; false when an admin issued it. Default:
+            False.
+        max_role (AccessRoleNullableType1 | AccessRoleNullableType2Type1 | AccessRoleNullableType3Type1 | None | Unset):
+    """
+
+    id: int
+    principal_object_id: str
+    name: str
+    prefix: str
+    created_by_object_id: None | str
+    created_at: datetime.datetime
+    expires_at: datetime.datetime
+    last_used_at: datetime.datetime | None
+    revoked_at: datetime.datetime | None
+    status: ApiTokenStatus
+    personal: bool | Unset = False
+    max_role: (
+        AccessRoleNullableType1
+        | AccessRoleNullableType2Type1
+        | AccessRoleNullableType3Type1
+        | None
+        | Unset
+    ) = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        principal_object_id = self.principal_object_id
+
+        name = self.name
+
+        prefix = self.prefix
+
+        created_by_object_id: None | str
+        created_by_object_id = self.created_by_object_id
+
+        created_at = self.created_at.isoformat()
+
+        expires_at = self.expires_at.isoformat()
+
+        last_used_at: None | str
+        if isinstance(self.last_used_at, datetime.datetime):
+            last_used_at = self.last_used_at.isoformat()
+        else:
+            last_used_at = self.last_used_at
+
+        revoked_at: None | str
+        if isinstance(self.revoked_at, datetime.datetime):
+            revoked_at = self.revoked_at.isoformat()
+        else:
+            revoked_at = self.revoked_at
+
+        status = self.status.value
+
+        personal = self.personal
+
+        max_role: None | str | Unset
+        if isinstance(self.max_role, Unset):
+            max_role = UNSET
+        elif isinstance(self.max_role, AccessRoleNullableType1):
+            max_role = self.max_role.value
+        elif isinstance(self.max_role, AccessRoleNullableType2Type1):
+            max_role = self.max_role.value
+        elif isinstance(self.max_role, AccessRoleNullableType3Type1):
+            max_role = self.max_role.value
+        else:
+            max_role = self.max_role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "principal_object_id": principal_object_id,
+                "name": name,
+                "prefix": prefix,
+                "created_by_object_id": created_by_object_id,
+                "created_at": created_at,
+                "expires_at": expires_at,
+                "last_used_at": last_used_at,
+                "revoked_at": revoked_at,
+                "status": status,
+            }
+        )
+        if personal is not UNSET:
+            field_dict["personal"] = personal
+        if max_role is not UNSET:
+            field_dict["max_role"] = max_role
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        principal_object_id = d.pop("principal_object_id")
+
+        name = d.pop("name")
+
+        prefix = d.pop("prefix")
+
+        def _parse_created_by_object_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        created_by_object_id = _parse_created_by_object_id(d.pop("created_by_object_id"))
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        expires_at = datetime.datetime.fromisoformat(d.pop("expires_at"))
+
+        def _parse_last_used_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_instant_nullable_type_1 = datetime.datetime.fromisoformat(data)
+
+                return componentsschemas_instant_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        last_used_at = _parse_last_used_at(d.pop("last_used_at"))
+
+        def _parse_revoked_at(data: object) -> datetime.datetime | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_instant_nullable_type_1 = datetime.datetime.fromisoformat(data)
+
+                return componentsschemas_instant_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None, data)
+
+        revoked_at = _parse_revoked_at(d.pop("revoked_at"))
+
+        status = ApiTokenStatus(d.pop("status"))
+
+        personal = d.pop("personal", UNSET)
+
+        def _parse_max_role(
+            data: object,
+        ) -> (
+            AccessRoleNullableType1
+            | AccessRoleNullableType2Type1
+            | AccessRoleNullableType3Type1
+            | None
+            | Unset
+        ):
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_1 = AccessRoleNullableType1(data)
+
+                return componentsschemas_access_role_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_2_type_1 = AccessRoleNullableType2Type1(
+                    data
+                )
+
+                return componentsschemas_access_role_nullable_type_2_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_3_type_1 = AccessRoleNullableType3Type1(
+                    data
+                )
+
+                return componentsschemas_access_role_nullable_type_3_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                AccessRoleNullableType1
+                | AccessRoleNullableType2Type1
+                | AccessRoleNullableType3Type1
+                | None
+                | Unset,
+                data,
+            )
+
+        max_role = _parse_max_role(d.pop("max_role", UNSET))
+
+        api_token_response = cls(
+            id=id,
+            principal_object_id=principal_object_id,
+            name=name,
+            prefix=prefix,
+            created_by_object_id=created_by_object_id,
+            created_at=created_at,
+            expires_at=expires_at,
+            last_used_at=last_used_at,
+            revoked_at=revoked_at,
+            status=status,
+            personal=personal,
+            max_role=max_role,
+        )
+
+        api_token_response.additional_properties = d
+        return api_token_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

docket/models/api_token_status.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ApiTokenStatus(str, Enum):
+    ACTIVE = "active"
+    EXPIRED = "expired"
+    REVOKED = "revoked"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/archive_recurring_acquisition_request.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.future_occurrences import FutureOccurrences
+
+
+T = TypeVar("T", bound="ArchiveRecurringAcquisitionRequest")
+
+
+@_attrs_define
+class ArchiveRecurringAcquisitionRequest:
+    """Archive a definition: it generates nothing further, and its history is kept.
+
+    Attributes:
+        expected_version (int): The `version` the client last read. A stale value is rejected with 409
+            `version_conflict`.
+        future_occurrences (FutureOccurrences): What archiving a definition does to occurrences that have not started
+            yet.
+    """
+
+    expected_version: int
+    future_occurrences: FutureOccurrences
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        expected_version = self.expected_version
+
+        future_occurrences = self.future_occurrences.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expected_version": expected_version,
+                "future_occurrences": future_occurrences,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        expected_version = d.pop("expected_version")
+
+        future_occurrences = FutureOccurrences(d.pop("future_occurrences"))
+
+        archive_recurring_acquisition_request = cls(
+            expected_version=expected_version,
+            future_occurrences=future_occurrences,
+        )
+
+        archive_recurring_acquisition_request.additional_properties = d
+        return archive_recurring_acquisition_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

docket/models/archive_recurring_acquisition_response.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from typing import cast
+
+if TYPE_CHECKING:
+    from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+
+T = TypeVar("T", bound="ArchiveRecurringAcquisitionResponse")
+
+
+@_attrs_define
+class ArchiveRecurringAcquisitionResponse:
+    """An archived definition and the occurrences archived with it.
+
+    Attributes:
+        definition (RecurringAcquisitionResponse): A recurring definition: scheduling intent, from which occurrences
+            were materialized.
+        archived_occurrence_ids (list[int]): Occurrences archived by this call.
+    """
+
+    definition: RecurringAcquisitionResponse
+    archived_occurrence_ids: list[int]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+        definition = self.definition.to_dict()
+
+        archived_occurrence_ids = self.archived_occurrence_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "definition": definition,
+                "archived_occurrence_ids": archived_occurrence_ids,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+        d = dict(src_dict)
+        definition = RecurringAcquisitionResponse.from_dict(d.pop("definition"))
+
+        archived_occurrence_ids = cast(list[int], d.pop("archived_occurrence_ids"))
+
+        archive_recurring_acquisition_response = cls(
+            definition=definition,
+            archived_occurrence_ids=archived_occurrence_ids,
+        )
+
+        archive_recurring_acquisition_response.additional_properties = d
+        return archive_recurring_acquisition_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties