docket-client 0.3.2__py3-none-any.whl

docket/models/create_scheduled_acquisition_request.py

@@ -0,0 +1,265 @@
+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 ..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.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="CreateScheduledAcquisitionRequest")
+
+
+@_attrs_define
+class CreateScheduledAcquisitionRequest:
+    """Plan one acquisition.
+
+    Attributes:
+        subject_id (str): Subject; validated against the metadata service.
+        instrument_id (str): Instrument (MPE comp_id); must be in the synced list.
+        project_id (str): Project; must be in the synced list.
+        scheduled_start (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        scheduled_end (datetime.datetime | None | Unset): Planned end, after the start; null when open-ended.
+        operator_instructions (str | Unset): Free text for the operator. Default: ''.
+        people (list[PersonAssignment] | None | Unset): People and their roles.
+        type_refs (list[SettingsSelector] | None | Unset): How each acquisition type's settings are chosen; at most one
+            per type.
+        variables (list[AcquisitionVariable] | None | Unset): Key/value inputs for the rig or operator.
+    """
+
+    subject_id: str
+    instrument_id: str
+    project_id: str
+    scheduled_start: datetime.datetime
+    scheduled_end: datetime.datetime | None | Unset = UNSET
+    operator_instructions: str | Unset = ""
+    people: list[PersonAssignment] | None | Unset = UNSET
+    type_refs: list[SettingsSelector] | None | Unset = UNSET
+    variables: list[AcquisitionVariable] | None | Unset = UNSET
+    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.settings_selector import SettingsSelector
+
+        subject_id = self.subject_id
+
+        instrument_id = self.instrument_id
+
+        project_id = self.project_id
+
+        scheduled_start = self.scheduled_start.isoformat()
+
+        scheduled_end: None | str | Unset
+        if isinstance(self.scheduled_end, Unset):
+            scheduled_end = UNSET
+        elif isinstance(self.scheduled_end, datetime.datetime):
+            scheduled_end = self.scheduled_end.isoformat()
+        else:
+            scheduled_end = self.scheduled_end
+
+        operator_instructions = self.operator_instructions
+
+        people: list[dict[str, Any]] | None | Unset
+        if isinstance(self.people, Unset):
+            people = UNSET
+        elif isinstance(self.people, list):
+            people = []
+            for people_type_1_item_data in self.people:
+                people_type_1_item = people_type_1_item_data.to_dict()
+                people.append(people_type_1_item)
+
+        else:
+            people = self.people
+
+        type_refs: list[dict[str, Any]] | None | Unset
+        if isinstance(self.type_refs, Unset):
+            type_refs = UNSET
+        elif isinstance(self.type_refs, list):
+            type_refs = []
+            for type_refs_type_1_item_data in self.type_refs:
+                type_refs_type_1_item = type_refs_type_1_item_data.to_dict()
+                type_refs.append(type_refs_type_1_item)
+
+        else:
+            type_refs = self.type_refs
+
+        variables: list[dict[str, Any]] | None | Unset
+        if isinstance(self.variables, Unset):
+            variables = UNSET
+        elif isinstance(self.variables, list):
+            variables = []
+            for variables_type_1_item_data in self.variables:
+                variables_type_1_item = variables_type_1_item_data.to_dict()
+                variables.append(variables_type_1_item)
+
+        else:
+            variables = self.variables
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "subject_id": subject_id,
+                "instrument_id": instrument_id,
+                "project_id": project_id,
+                "scheduled_start": scheduled_start,
+            }
+        )
+        if scheduled_end is not UNSET:
+            field_dict["scheduled_end"] = scheduled_end
+        if operator_instructions is not UNSET:
+            field_dict["operator_instructions"] = operator_instructions
+        if people is not UNSET:
+            field_dict["people"] = people
+        if type_refs is not UNSET:
+            field_dict["type_refs"] = type_refs
+        if variables is not UNSET:
+            field_dict["variables"] = variables
+
+        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.settings_selector import SettingsSelector
+
+        d = dict(src_dict)
+        subject_id = d.pop("subject_id")
+
+        instrument_id = d.pop("instrument_id")
+
+        project_id = d.pop("project_id")
+
+        scheduled_start = datetime.datetime.fromisoformat(d.pop("scheduled_start"))
+
+        def _parse_scheduled_end(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                scheduled_end_type_1 = datetime.datetime.fromisoformat(data)
+
+                return scheduled_end_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        scheduled_end = _parse_scheduled_end(d.pop("scheduled_end", UNSET))
+
+        operator_instructions = d.pop("operator_instructions", UNSET)
+
+        def _parse_people(data: object) -> list[PersonAssignment] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                people_type_1 = []
+                _people_type_1 = data
+                for people_type_1_item_data in _people_type_1:
+                    people_type_1_item = PersonAssignment.from_dict(people_type_1_item_data)
+
+                    people_type_1.append(people_type_1_item)
+
+                return people_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[PersonAssignment] | None | Unset, data)
+
+        people = _parse_people(d.pop("people", UNSET))
+
+        def _parse_type_refs(data: object) -> list[SettingsSelector] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                type_refs_type_1 = []
+                _type_refs_type_1 = data
+                for type_refs_type_1_item_data in _type_refs_type_1:
+                    type_refs_type_1_item = SettingsSelector.from_dict(type_refs_type_1_item_data)
+
+                    type_refs_type_1.append(type_refs_type_1_item)
+
+                return type_refs_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[SettingsSelector] | None | Unset, data)
+
+        type_refs = _parse_type_refs(d.pop("type_refs", UNSET))
+
+        def _parse_variables(data: object) -> list[AcquisitionVariable] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                variables_type_1 = []
+                _variables_type_1 = data
+                for variables_type_1_item_data in _variables_type_1:
+                    variables_type_1_item = AcquisitionVariable.from_dict(
+                        variables_type_1_item_data
+                    )
+
+                    variables_type_1.append(variables_type_1_item)
+
+                return variables_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[AcquisitionVariable] | None | Unset, data)
+
+        variables = _parse_variables(d.pop("variables", UNSET))
+
+        create_scheduled_acquisition_request = cls(
+            subject_id=subject_id,
+            instrument_id=instrument_id,
+            project_id=project_id,
+            scheduled_start=scheduled_start,
+            scheduled_end=scheduled_end,
+            operator_instructions=operator_instructions,
+            people=people,
+            type_refs=type_refs,
+            variables=variables,
+        )
+
+        create_scheduled_acquisition_request.additional_properties = d
+        return create_scheduled_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/create_template_request.py

@@ -0,0 +1,323 @@
+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 ..types import UNSET, Unset
+from typing import cast
+
+if TYPE_CHECKING:
+    from ..models.acquisition_variable import AcquisitionVariable
+    from ..models.person_assignment import PersonAssignment
+    from ..models.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="CreateTemplateRequest")
+
+
+@_attrs_define
+class CreateTemplateRequest:
+    """A named set of optional scheduling defaults. Using a template is a client-side
+    prefill: the form copies the defaults, the user adjusts them, and the normal
+    create request is validated as usual. Nothing refers back to the template, so
+    editing it affects only later uses.
+
+        Attributes:
+            name (str): Unique among non-archived templates, ignoring case and surrounding spaces.
+            subject_id (None | str | Unset): Default subject; not validated until a template is used.
+            instrument_id (None | str | Unset): Default instrument; validated against the synced list.
+            project_id (None | str | Unset): Default project; validated against the synced list.
+            operator_instructions (None | str | Unset): Default operator text.
+            people (list[PersonAssignment] | None | Unset): Default people and roles.
+            type_refs (list[SettingsSelector] | None | Unset): Default settings selectors; at most one per acquisition type.
+            variables (list[AcquisitionVariable] | None | Unset): Default variables.
+            duration_minutes (int | None | Unset): Default length of an acquisition in minutes.
+            local_start_time (None | str | Unset): Default wall-clock start time of day.
+    """
+
+    name: str
+    subject_id: None | str | Unset = UNSET
+    instrument_id: None | str | Unset = UNSET
+    project_id: None | str | Unset = UNSET
+    operator_instructions: None | str | Unset = UNSET
+    people: list[PersonAssignment] | None | Unset = UNSET
+    type_refs: list[SettingsSelector] | None | Unset = UNSET
+    variables: list[AcquisitionVariable] | None | Unset = UNSET
+    duration_minutes: int | None | Unset = UNSET
+    local_start_time: None | str | Unset = UNSET
+    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.settings_selector import SettingsSelector
+
+        name = self.name
+
+        subject_id: None | str | Unset
+        if isinstance(self.subject_id, Unset):
+            subject_id = UNSET
+        else:
+            subject_id = self.subject_id
+
+        instrument_id: None | str | Unset
+        if isinstance(self.instrument_id, Unset):
+            instrument_id = UNSET
+        else:
+            instrument_id = self.instrument_id
+
+        project_id: None | str | Unset
+        if isinstance(self.project_id, Unset):
+            project_id = UNSET
+        else:
+            project_id = self.project_id
+
+        operator_instructions: None | str | Unset
+        if isinstance(self.operator_instructions, Unset):
+            operator_instructions = UNSET
+        else:
+            operator_instructions = self.operator_instructions
+
+        people: list[dict[str, Any]] | None | Unset
+        if isinstance(self.people, Unset):
+            people = UNSET
+        elif isinstance(self.people, list):
+            people = []
+            for people_type_1_item_data in self.people:
+                people_type_1_item = people_type_1_item_data.to_dict()
+                people.append(people_type_1_item)
+
+        else:
+            people = self.people
+
+        type_refs: list[dict[str, Any]] | None | Unset
+        if isinstance(self.type_refs, Unset):
+            type_refs = UNSET
+        elif isinstance(self.type_refs, list):
+            type_refs = []
+            for type_refs_type_1_item_data in self.type_refs:
+                type_refs_type_1_item = type_refs_type_1_item_data.to_dict()
+                type_refs.append(type_refs_type_1_item)
+
+        else:
+            type_refs = self.type_refs
+
+        variables: list[dict[str, Any]] | None | Unset
+        if isinstance(self.variables, Unset):
+            variables = UNSET
+        elif isinstance(self.variables, list):
+            variables = []
+            for variables_type_1_item_data in self.variables:
+                variables_type_1_item = variables_type_1_item_data.to_dict()
+                variables.append(variables_type_1_item)
+
+        else:
+            variables = self.variables
+
+        duration_minutes: int | None | Unset
+        if isinstance(self.duration_minutes, Unset):
+            duration_minutes = UNSET
+        else:
+            duration_minutes = self.duration_minutes
+
+        local_start_time: None | str | Unset
+        if isinstance(self.local_start_time, Unset):
+            local_start_time = UNSET
+        else:
+            local_start_time = self.local_start_time
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if subject_id is not UNSET:
+            field_dict["subject_id"] = subject_id
+        if instrument_id is not UNSET:
+            field_dict["instrument_id"] = instrument_id
+        if project_id is not UNSET:
+            field_dict["project_id"] = project_id
+        if operator_instructions is not UNSET:
+            field_dict["operator_instructions"] = operator_instructions
+        if people is not UNSET:
+            field_dict["people"] = people
+        if type_refs is not UNSET:
+            field_dict["type_refs"] = type_refs
+        if variables is not UNSET:
+            field_dict["variables"] = variables
+        if duration_minutes is not UNSET:
+            field_dict["duration_minutes"] = duration_minutes
+        if local_start_time is not UNSET:
+            field_dict["local_start_time"] = local_start_time
+
+        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.settings_selector import SettingsSelector
+
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        def _parse_subject_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        subject_id = _parse_subject_id(d.pop("subject_id", UNSET))
+
+        def _parse_instrument_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        instrument_id = _parse_instrument_id(d.pop("instrument_id", UNSET))
+
+        def _parse_project_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        project_id = _parse_project_id(d.pop("project_id", UNSET))
+
+        def _parse_operator_instructions(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        operator_instructions = _parse_operator_instructions(d.pop("operator_instructions", UNSET))
+
+        def _parse_people(data: object) -> list[PersonAssignment] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                people_type_1 = []
+                _people_type_1 = data
+                for people_type_1_item_data in _people_type_1:
+                    people_type_1_item = PersonAssignment.from_dict(people_type_1_item_data)
+
+                    people_type_1.append(people_type_1_item)
+
+                return people_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[PersonAssignment] | None | Unset, data)
+
+        people = _parse_people(d.pop("people", UNSET))
+
+        def _parse_type_refs(data: object) -> list[SettingsSelector] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                type_refs_type_1 = []
+                _type_refs_type_1 = data
+                for type_refs_type_1_item_data in _type_refs_type_1:
+                    type_refs_type_1_item = SettingsSelector.from_dict(type_refs_type_1_item_data)
+
+                    type_refs_type_1.append(type_refs_type_1_item)
+
+                return type_refs_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[SettingsSelector] | None | Unset, data)
+
+        type_refs = _parse_type_refs(d.pop("type_refs", UNSET))
+
+        def _parse_variables(data: object) -> list[AcquisitionVariable] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                variables_type_1 = []
+                _variables_type_1 = data
+                for variables_type_1_item_data in _variables_type_1:
+                    variables_type_1_item = AcquisitionVariable.from_dict(
+                        variables_type_1_item_data
+                    )
+
+                    variables_type_1.append(variables_type_1_item)
+
+                return variables_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[AcquisitionVariable] | None | Unset, data)
+
+        variables = _parse_variables(d.pop("variables", UNSET))
+
+        def _parse_duration_minutes(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        duration_minutes = _parse_duration_minutes(d.pop("duration_minutes", UNSET))
+
+        def _parse_local_start_time(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        local_start_time = _parse_local_start_time(d.pop("local_start_time", UNSET))
+
+        create_template_request = cls(
+            name=name,
+            subject_id=subject_id,
+            instrument_id=instrument_id,
+            project_id=project_id,
+            operator_instructions=operator_instructions,
+            people=people,
+            type_refs=type_refs,
+            variables=variables,
+            duration_minutes=duration_minutes,
+            local_start_time=local_start_time,
+        )
+
+        create_template_request.additional_properties = d
+        return create_template_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/created_api_token_response.py

@@ -0,0 +1,82 @@
+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.api_token_response import ApiTokenResponse
+
+
+T = TypeVar("T", bound="CreatedApiTokenResponse")
+
+
+@_attrs_define
+class CreatedApiTokenResponse:
+    """A newly issued token. `token` is the only time the secret is returned.
+
+    Attributes:
+        token (str): The full token (`dkt_` + 43 characters). Copy it now; it is not stored and cannot be shown again.
+        metadata (ApiTokenResponse): An API token's metadata. The secret is shown once, when created, and never again.
+    """
+
+    token: str
+    metadata: ApiTokenResponse
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.api_token_response import ApiTokenResponse
+
+        token = self.token
+
+        metadata = self.metadata.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "token": token,
+                "metadata": metadata,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.api_token_response import ApiTokenResponse
+
+        d = dict(src_dict)
+        token = d.pop("token")
+
+        metadata = ApiTokenResponse.from_dict(d.pop("metadata"))
+
+        created_api_token_response = cls(
+            token=token,
+            metadata=metadata,
+        )
+
+        created_api_token_response.additional_properties = d
+        return created_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/effective_status.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class EffectiveStatus(str, Enum):
+    CANCELLED = "cancelled"
+    COMPLETED = "completed"
+    ERRORED = "errored"
+    FAILED = "failed"
+    ONGOING = "ongoing"
+    SCHEDULED = "scheduled"
+    SUCCEEDED = "succeeded"
+    TIMED_OUT = "timed_out"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/fip_color.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class FipColor(str, Enum):
+    BLUE = "Blue"
+    GREEN = "Green"
+    ORANGE = "Orange"
+    PURPLE = "Purple"
+    RED = "Red"
+    YELLOW = "Yellow"
+
+    def __str__(self) -> str:
+        return str(self.value)