docket-client 0.3.2__py3-none-any.whl

docket/models/recurring_acquisition_response.py

@@ -0,0 +1,326 @@
+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
+
+if TYPE_CHECKING:
+    from ..models.acquisition_variable import AcquisitionVariable
+    from ..models.person_assignment import PersonAssignment
+    from ..models.recurrence_rule import RecurrenceRule
+    from ..models.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="RecurringAcquisitionResponse")
+
+
+@_attrs_define
+class RecurringAcquisitionResponse:
+    """A recurring definition: scheduling intent, from which occurrences were materialized.
+
+    Attributes:
+        id (int): Definition id.
+        subject_id (str): Subject of every occurrence.
+        instrument_id (str): Instrument of every occurrence.
+        project_id (str): Project of every occurrence.
+        rule (RecurrenceRule): When a series occurs. Occurrences are computed from the local date and
+            `local_start_time` in `time_zone`, so 09:00
+            stays 09:00 across daylight-saving changes. Exactly one of
+            `count` and `until` is required (finite series only).
+        operator_instructions (str): Free text copied onto every occurrence.
+        people (list[PersonAssignment]): People and roles copied onto every occurrence.
+        type_refs (list[SettingsSelector]): Settings selectors copied onto every occurrence.
+        variables (list[AcquisitionVariable]): Variables copied onto every occurrence.
+        created_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        created_by (str): Display name of the creator.
+        created_by_object_id (None | str): Directory object id of the creator; null for rows made while authentication
+            was off.
+        archived_at (datetime.datetime | None):
+        version (int): Opaque row version; send it back as `expected_version`.
+        next_start (datetime.datetime | None):
+        remaining (int): Number of future, non-archived occurrences (start after now).
+        previous_id (int | None): The definition this one continues, when it was created by a split.
+        superseded_by_id (int | None): The definition that continues this one after a split; null while this is the
+            current series.
+        ended_on (datetime.date | None):
+    """
+
+    id: int
+    subject_id: str
+    instrument_id: str
+    project_id: str
+    rule: RecurrenceRule
+    operator_instructions: str
+    people: list[PersonAssignment]
+    type_refs: list[SettingsSelector]
+    variables: list[AcquisitionVariable]
+    created_at: datetime.datetime
+    created_by: str
+    created_by_object_id: None | str
+    archived_at: datetime.datetime | None
+    version: int
+    next_start: datetime.datetime | None
+    remaining: int
+    previous_id: int | None
+    superseded_by_id: int | None
+    ended_on: datetime.date | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.acquisition_variable import AcquisitionVariable
+        from ..models.person_assignment import PersonAssignment
+        from ..models.recurrence_rule import RecurrenceRule
+        from ..models.settings_selector import SettingsSelector
+
+        id = self.id
+
+        subject_id = self.subject_id
+
+        instrument_id = self.instrument_id
+
+        project_id = self.project_id
+
+        rule = self.rule.to_dict()
+
+        operator_instructions = self.operator_instructions
+
+        people = []
+        for people_item_data in self.people:
+            people_item = people_item_data.to_dict()
+            people.append(people_item)
+
+        type_refs = []
+        for type_refs_item_data in self.type_refs:
+            type_refs_item = type_refs_item_data.to_dict()
+            type_refs.append(type_refs_item)
+
+        variables = []
+        for variables_item_data in self.variables:
+            variables_item = variables_item_data.to_dict()
+            variables.append(variables_item)
+
+        created_at = self.created_at.isoformat()
+
+        created_by = self.created_by
+
+        created_by_object_id: None | str
+        created_by_object_id = self.created_by_object_id
+
+        archived_at: None | str
+        if isinstance(self.archived_at, datetime.datetime):
+            archived_at = self.archived_at.isoformat()
+        else:
+            archived_at = self.archived_at
+
+        version = self.version
+
+        next_start: None | str
+        if isinstance(self.next_start, datetime.datetime):
+            next_start = self.next_start.isoformat()
+        else:
+            next_start = self.next_start
+
+        remaining = self.remaining
+
+        previous_id: int | None
+        previous_id = self.previous_id
+
+        superseded_by_id: int | None
+        superseded_by_id = self.superseded_by_id
+
+        ended_on: None | str
+        if isinstance(self.ended_on, datetime.date):
+            ended_on = self.ended_on.isoformat()
+        else:
+            ended_on = self.ended_on
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "subject_id": subject_id,
+                "instrument_id": instrument_id,
+                "project_id": project_id,
+                "rule": rule,
+                "operator_instructions": operator_instructions,
+                "people": people,
+                "type_refs": type_refs,
+                "variables": variables,
+                "created_at": created_at,
+                "created_by": created_by,
+                "created_by_object_id": created_by_object_id,
+                "archived_at": archived_at,
+                "version": version,
+                "next_start": next_start,
+                "remaining": remaining,
+                "previous_id": previous_id,
+                "superseded_by_id": superseded_by_id,
+                "ended_on": ended_on,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.acquisition_variable import AcquisitionVariable
+        from ..models.person_assignment import PersonAssignment
+        from ..models.recurrence_rule import RecurrenceRule
+        from ..models.settings_selector import SettingsSelector
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        subject_id = d.pop("subject_id")
+
+        instrument_id = d.pop("instrument_id")
+
+        project_id = d.pop("project_id")
+
+        rule = RecurrenceRule.from_dict(d.pop("rule"))
+
+        operator_instructions = d.pop("operator_instructions")
+
+        people = []
+        _people = d.pop("people")
+        for people_item_data in _people:
+            people_item = PersonAssignment.from_dict(people_item_data)
+
+            people.append(people_item)
+
+        type_refs = []
+        _type_refs = d.pop("type_refs")
+        for type_refs_item_data in _type_refs:
+            type_refs_item = SettingsSelector.from_dict(type_refs_item_data)
+
+            type_refs.append(type_refs_item)
+
+        variables = []
+        _variables = d.pop("variables")
+        for variables_item_data in _variables:
+            variables_item = AcquisitionVariable.from_dict(variables_item_data)
+
+            variables.append(variables_item)
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        created_by = d.pop("created_by")
+
+        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"))
+
+        def _parse_archived_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)
+
+        archived_at = _parse_archived_at(d.pop("archived_at"))
+
+        version = d.pop("version")
+
+        def _parse_next_start(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)
+
+        next_start = _parse_next_start(d.pop("next_start"))
+
+        remaining = d.pop("remaining")
+
+        def _parse_previous_id(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        previous_id = _parse_previous_id(d.pop("previous_id"))
+
+        def _parse_superseded_by_id(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        superseded_by_id = _parse_superseded_by_id(d.pop("superseded_by_id"))
+
+        def _parse_ended_on(data: object) -> datetime.date | None:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_local_date_nullable_type_1 = datetime.date.fromisoformat(data)
+
+                return componentsschemas_local_date_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.date | None, data)
+
+        ended_on = _parse_ended_on(d.pop("ended_on"))
+
+        recurring_acquisition_response = cls(
+            id=id,
+            subject_id=subject_id,
+            instrument_id=instrument_id,
+            project_id=project_id,
+            rule=rule,
+            operator_instructions=operator_instructions,
+            people=people,
+            type_refs=type_refs,
+            variables=variables,
+            created_at=created_at,
+            created_by=created_by,
+            created_by_object_id=created_by_object_id,
+            archived_at=archived_at,
+            version=version,
+            next_start=next_start,
+            remaining=remaining,
+            previous_id=previous_id,
+            superseded_by_id=superseded_by_id,
+            ended_on=ended_on,
+        )
+
+        recurring_acquisition_response.additional_properties = d
+        return 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

docket/models/report_run_outcome_request.py

@@ -0,0 +1,89 @@
+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.run_outcome import RunOutcome
+from ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="ReportRunOutcomeRequest")
+
+
+@_attrs_define
+class ReportRunOutcomeRequest:
+    """Report how a run ended.
+
+    Attributes:
+        status (RunOutcome): An outcome a client may report.
+        error_detail (None | str | Unset): Only for `errored`.
+    """
+
+    status: RunOutcome
+    error_detail: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        error_detail: None | str | Unset
+        if isinstance(self.error_detail, Unset):
+            error_detail = UNSET
+        else:
+            error_detail = self.error_detail
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+        if error_detail is not UNSET:
+            field_dict["error_detail"] = error_detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        status = RunOutcome(d.pop("status"))
+
+        def _parse_error_detail(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error_detail = _parse_error_detail(d.pop("error_detail", UNSET))
+
+        report_run_outcome_request = cls(
+            status=status,
+            error_detail=error_detail,
+        )
+
+        report_run_outcome_request.additional_properties = d
+        return report_run_outcome_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/resolution_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class ResolutionMode(str, Enum):
+    DISCRIMINATOR = "discriminator"
+    MOST_RECENT = "most_recent"
+    PINNED = "pinned"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/resolved_settings.py

@@ -0,0 +1,73 @@
+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
+
+
+T = TypeVar("T", bound="ResolvedSettings")
+
+
+@_attrs_define
+class ResolvedSettings:
+    """A resolved settings version.
+
+    Attributes:
+        settings_id (int): The version id.
+        settings (Any):
+    """
+
+    settings_id: int
+    settings: Any
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        settings_id = self.settings_id
+
+        settings = self.settings
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "settings_id": settings_id,
+                "settings": settings,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        settings_id = d.pop("settings_id")
+
+        settings = d.pop("settings")
+
+        resolved_settings = cls(
+            settings_id=settings_id,
+            settings=settings,
+        )
+
+        resolved_settings.additional_properties = d
+        return resolved_settings
+
+    @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/role_assignment_response.py

@@ -0,0 +1,157 @@
+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 import AccessRole
+from ..models.principal_kind import PrincipalKind
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="RoleAssignmentResponse")
+
+
+@_attrs_define
+class RoleAssignmentResponse:
+    """One role assignment row.
+
+    Attributes:
+        id (int): Assignment id.
+        principal_object_id (str): Who holds the role.
+        principal_kind (PrincipalKind): What kind of directory principal a role is held by.
+        role (AccessRole): A role Docket grants. Roles live in Docket's database; Entra only proves
+            who the caller is, and the token's own `roles` claim is ignored.
+        scope (None | str): Acquisition-type key for an acquisition settings maintainer; null means all acquisition
+            types.
+        granted_by_object_id (None | str): Who granted it; null if granted while authentication was off.
+        granted_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        archived_at (datetime.datetime | None):
+    """
+
+    id: int
+    principal_object_id: str
+    principal_kind: PrincipalKind
+    role: AccessRole
+    scope: None | str
+    granted_by_object_id: None | str
+    granted_at: datetime.datetime
+    archived_at: datetime.datetime | None
+    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
+
+        principal_kind = self.principal_kind.value
+
+        role = self.role.value
+
+        scope: None | str
+        scope = self.scope
+
+        granted_by_object_id: None | str
+        granted_by_object_id = self.granted_by_object_id
+
+        granted_at = self.granted_at.isoformat()
+
+        archived_at: None | str
+        if isinstance(self.archived_at, datetime.datetime):
+            archived_at = self.archived_at.isoformat()
+        else:
+            archived_at = self.archived_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "principal_object_id": principal_object_id,
+                "principal_kind": principal_kind,
+                "role": role,
+                "scope": scope,
+                "granted_by_object_id": granted_by_object_id,
+                "granted_at": granted_at,
+                "archived_at": archived_at,
+            }
+        )
+
+        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")
+
+        principal_kind = PrincipalKind(d.pop("principal_kind"))
+
+        role = AccessRole(d.pop("role"))
+
+        def _parse_scope(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        scope = _parse_scope(d.pop("scope"))
+
+        def _parse_granted_by_object_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        granted_by_object_id = _parse_granted_by_object_id(d.pop("granted_by_object_id"))
+
+        granted_at = datetime.datetime.fromisoformat(d.pop("granted_at"))
+
+        def _parse_archived_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)
+
+        archived_at = _parse_archived_at(d.pop("archived_at"))
+
+        role_assignment_response = cls(
+            id=id,
+            principal_object_id=principal_object_id,
+            principal_kind=principal_kind,
+            role=role,
+            scope=scope,
+            granted_by_object_id=granted_by_object_id,
+            granted_at=granted_at,
+            archived_at=archived_at,
+        )
+
+        role_assignment_response.additional_properties = d
+        return role_assignment_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/role_origin.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class RoleOrigin(str, Enum):
+    ASSIGNMENT = "assignment"
+    BOOTSTRAP = "bootstrap"
+    DEFAULT = "default"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/role_source_kind.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class RoleSourceKind(str, Enum):
+    ASSIGNMENT = "assignment"
+    BOOTSTRAP = "bootstrap"
+    DEFAULT = "default"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/run_origin.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RunOrigin(str, Enum):
+    CLABE = "clabe"
+    MANUAL = "manual"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/run_outcome.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RunOutcome(str, Enum):
+    COMPLETED = "completed"
+    ERRORED = "errored"
+
+    def __str__(self) -> str:
+        return str(self.value)