docket-client 0.3.2__py3-none-any.whl

docket/models/template_response.py

@@ -0,0 +1,302 @@
+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.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="TemplateResponse")
+
+
+@_attrs_define
+class TemplateResponse:
+    """A template.
+
+    Attributes:
+        id (int):
+        name (str):
+        subject_id (None | str):
+        instrument_id (None | str):
+        project_id (None | str):
+        operator_instructions (None | str):
+        people (list[PersonAssignment]):
+        type_refs (list[SettingsSelector]):
+        variables (list[AcquisitionVariable]):
+        duration_minutes (int | None):
+        local_start_time (None | str):
+        created_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        created_by (str):
+        created_by_object_id (None | str): Directory object id of the creator; null for rows made while authentication
+            was off. Only the creator (and maintainers) can change the row.
+        updated_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        updated_by (str):
+        archived_at (datetime.datetime | None):
+        version (int): Opaque row version (PostgreSQL xmin). Changes on every edit; send it back as expected_version.
+            Not a counter.
+    """
+
+    id: int
+    name: str
+    subject_id: None | str
+    instrument_id: None | str
+    project_id: None | str
+    operator_instructions: None | str
+    people: list[PersonAssignment]
+    type_refs: list[SettingsSelector]
+    variables: list[AcquisitionVariable]
+    duration_minutes: int | None
+    local_start_time: None | str
+    created_at: datetime.datetime
+    created_by: str
+    created_by_object_id: None | str
+    updated_at: datetime.datetime
+    updated_by: str
+    archived_at: datetime.datetime | None
+    version: int
+    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
+
+        id = self.id
+
+        name = self.name
+
+        subject_id: None | str
+        subject_id = self.subject_id
+
+        instrument_id: None | str
+        instrument_id = self.instrument_id
+
+        project_id: None | str
+        project_id = self.project_id
+
+        operator_instructions: None | str
+        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)
+
+        duration_minutes: int | None
+        duration_minutes = self.duration_minutes
+
+        local_start_time: None | str
+        local_start_time = self.local_start_time
+
+        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
+
+        updated_at = self.updated_at.isoformat()
+
+        updated_by = self.updated_by
+
+        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
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "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,
+                "created_at": created_at,
+                "created_by": created_by,
+                "created_by_object_id": created_by_object_id,
+                "updated_at": updated_at,
+                "updated_by": updated_by,
+                "archived_at": archived_at,
+                "version": version,
+            }
+        )
+
+        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)
+        id = d.pop("id")
+
+        name = d.pop("name")
+
+        def _parse_subject_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        subject_id = _parse_subject_id(d.pop("subject_id"))
+
+        def _parse_instrument_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        instrument_id = _parse_instrument_id(d.pop("instrument_id"))
+
+        def _parse_project_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        project_id = _parse_project_id(d.pop("project_id"))
+
+        def _parse_operator_instructions(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        operator_instructions = _parse_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)
+
+        def _parse_duration_minutes(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        duration_minutes = _parse_duration_minutes(d.pop("duration_minutes"))
+
+        def _parse_local_start_time(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        local_start_time = _parse_local_start_time(d.pop("local_start_time"))
+
+        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"))
+
+        updated_at = datetime.datetime.fromisoformat(d.pop("updated_at"))
+
+        updated_by = d.pop("updated_by")
+
+        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")
+
+        template_response = cls(
+            id=id,
+            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,
+            created_at=created_at,
+            created_by=created_by,
+            created_by_object_id=created_by_object_id,
+            updated_at=updated_at,
+            updated_by=updated_by,
+            archived_at=archived_at,
+            version=version,
+        )
+
+        template_response.additional_properties = d
+        return template_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/update_scheduled_acquisition_request.py

@@ -0,0 +1,235 @@
+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="UpdateScheduledAcquisitionRequest")
+
+
+@_attrs_define
+class UpdateScheduledAcquisitionRequest:
+    """Change a scheduled acquisition. Every field except `expected_version`
+    is optional: an omitted field is left unchanged. `people`,
+    `type_refs` and `variables` replace the whole list when present.
+
+        Attributes:
+            expected_version (int): The `version` the client last read. A stale value is rejected with 409
+                `version_conflict`.
+            subject_id (str | Unset): New subject; validated against the metadata service. The type refs (sent or kept) must
+                be valid for it, so a
+                pinned settings version of the old subject has to be replaced in the same edit. Rejected with 409
+                `acquisition_has_runs` once a run exists.
+            instrument_id (str | Unset): New instrument; must be in the synced list. Rejected with 409
+                `acquisition_has_runs` once a run exists.
+            project_id (str | Unset): New project; must be in the synced list.
+            scheduled_start (datetime.datetime | Unset): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+            scheduled_end (datetime.datetime | None | Unset):
+            operator_instructions (str | Unset): New operator text; an empty string clears it.
+            people (list[PersonAssignment] | Unset): Replaces the people list.
+            type_refs (list[SettingsSelector] | Unset): Replaces the type refs. Rejected with 409 `acquisition_has_runs`
+                once a run exists.
+            variables (list[AcquisitionVariable] | Unset): Replaces the variables.
+    """
+
+    expected_version: int
+    subject_id: str | Unset = UNSET
+    instrument_id: str | Unset = UNSET
+    project_id: str | Unset = UNSET
+    scheduled_start: datetime.datetime | Unset = UNSET
+    scheduled_end: datetime.datetime | None | Unset = UNSET
+    operator_instructions: str | Unset = UNSET
+    people: list[PersonAssignment] | Unset = UNSET
+    type_refs: list[SettingsSelector] | Unset = UNSET
+    variables: list[AcquisitionVariable] | 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
+
+        expected_version = self.expected_version
+
+        subject_id = self.subject_id
+
+        instrument_id = self.instrument_id
+
+        project_id = self.project_id
+
+        scheduled_start: str | Unset = UNSET
+        if not isinstance(self.scheduled_start, Unset):
+            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]] | Unset = UNSET
+        if not isinstance(self.people, Unset):
+            people = []
+            for people_item_data in self.people:
+                people_item = people_item_data.to_dict()
+                people.append(people_item)
+
+        type_refs: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.type_refs, Unset):
+            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: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.variables, Unset):
+            variables = []
+            for variables_item_data in self.variables:
+                variables_item = variables_item_data.to_dict()
+                variables.append(variables_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "expected_version": expected_version,
+            }
+        )
+        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 scheduled_start is not UNSET:
+            field_dict["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)
+        expected_version = d.pop("expected_version")
+
+        subject_id = d.pop("subject_id", UNSET)
+
+        instrument_id = d.pop("instrument_id", UNSET)
+
+        project_id = d.pop("project_id", UNSET)
+
+        _scheduled_start = d.pop("scheduled_start", UNSET)
+        scheduled_start: datetime.datetime | Unset
+        if isinstance(_scheduled_start, Unset):
+            scheduled_start = UNSET
+        else:
+            scheduled_start = datetime.datetime.fromisoformat(_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()
+                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 | Unset, data)
+
+        scheduled_end = _parse_scheduled_end(d.pop("scheduled_end", UNSET))
+
+        operator_instructions = d.pop("operator_instructions", UNSET)
+
+        _people = d.pop("people", UNSET)
+        people: list[PersonAssignment] | Unset = UNSET
+        if _people is not UNSET:
+            people = []
+            for people_item_data in _people:
+                people_item = PersonAssignment.from_dict(people_item_data)
+
+                people.append(people_item)
+
+        _type_refs = d.pop("type_refs", UNSET)
+        type_refs: list[SettingsSelector] | Unset = UNSET
+        if _type_refs is not UNSET:
+            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 = d.pop("variables", UNSET)
+        variables: list[AcquisitionVariable] | Unset = UNSET
+        if _variables is not UNSET:
+            variables = []
+            for variables_item_data in _variables:
+                variables_item = AcquisitionVariable.from_dict(variables_item_data)
+
+                variables.append(variables_item)
+
+        update_scheduled_acquisition_request = cls(
+            expected_version=expected_version,
+            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,
+        )
+
+        update_scheduled_acquisition_request.additional_properties = d
+        return update_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