docket-client 0.3.2__py3-none-any.whl

docket/models/scheduled_acquisition_response.py

@@ -0,0 +1,366 @@
+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.effective_status import EffectiveStatus
+from ..models.planning_status import PlanningStatus
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+    from ..models.acquisition_variable import AcquisitionVariable
+    from ..models.acquisition_warning import AcquisitionWarning
+    from ..models.person_assignment import PersonAssignment
+    from ..models.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="ScheduledAcquisitionResponse")
+
+
+@_attrs_define
+class ScheduledAcquisitionResponse:
+    """A planned acquisition.
+
+    Attributes:
+        id (int):
+        subject_id (str):
+        instrument_id (str):
+        project_id (str):
+        scheduled_start (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+        scheduled_end (datetime.datetime | None):
+        operator_instructions (str):
+        planning_status (PlanningStatus): A planned slot's own disposition, set by people (knowledge/decisions/0013).
+        effective_status (EffectiveStatus): What a scheduled acquisition reads as: a hand-set disposition when there is
+            one, otherwise its newest run's state, otherwise `scheduled`
+            (knowledge/decisions/0020).
+        has_runs (bool): Whether at least one run exists. Once true, subject, start, end, instrument and type refs can
+            no longer change (409 acquisition_has_runs), whatever the status says.
+        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.
+        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.
+        people (list[PersonAssignment]):
+        type_refs (list[SettingsSelector]):
+        task_name (None | str): The behavior curriculum task name this acquisition runs, resolved from its
+            behavior_curriculum type ref (pinned version, newest live version, or the discriminator value); null when it has
+            no such ref or the task is unknown. For labelling lists without a request per row.
+        variables (list[AcquisitionVariable]):
+        recurring_acquisition_id (int | None): The recurring definition this acquisition is an occurrence of; null for a
+            one-off.
+        occurrence_local_date (datetime.date | None):
+        warnings (list[AcquisitionWarning]): Overlap warnings. Filled only on create and edit responses; always empty
+            when reading.
+    """
+
+    id: int
+    subject_id: str
+    instrument_id: str
+    project_id: str
+    scheduled_start: datetime.datetime
+    scheduled_end: datetime.datetime | None
+    operator_instructions: str
+    planning_status: PlanningStatus
+    effective_status: EffectiveStatus
+    has_runs: bool
+    created_at: datetime.datetime
+    created_by: str
+    created_by_object_id: None | str
+    archived_at: datetime.datetime | None
+    version: int
+    people: list[PersonAssignment]
+    type_refs: list[SettingsSelector]
+    task_name: None | str
+    variables: list[AcquisitionVariable]
+    recurring_acquisition_id: int | None
+    occurrence_local_date: datetime.date | None
+    warnings: list[AcquisitionWarning]
+    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.acquisition_warning import AcquisitionWarning
+        from ..models.person_assignment import PersonAssignment
+        from ..models.settings_selector import SettingsSelector
+
+        id = self.id
+
+        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
+        if isinstance(self.scheduled_end, datetime.datetime):
+            scheduled_end = self.scheduled_end.isoformat()
+        else:
+            scheduled_end = self.scheduled_end
+
+        operator_instructions = self.operator_instructions
+
+        planning_status = self.planning_status.value
+
+        effective_status = self.effective_status.value
+
+        has_runs = self.has_runs
+
+        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
+
+        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)
+
+        task_name: None | str
+        task_name = self.task_name
+
+        variables = []
+        for variables_item_data in self.variables:
+            variables_item = variables_item_data.to_dict()
+            variables.append(variables_item)
+
+        recurring_acquisition_id: int | None
+        recurring_acquisition_id = self.recurring_acquisition_id
+
+        occurrence_local_date: None | str
+        if isinstance(self.occurrence_local_date, datetime.date):
+            occurrence_local_date = self.occurrence_local_date.isoformat()
+        else:
+            occurrence_local_date = self.occurrence_local_date
+
+        warnings = []
+        for warnings_item_data in self.warnings:
+            warnings_item = warnings_item_data.to_dict()
+            warnings.append(warnings_item)
+
+        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,
+                "scheduled_start": scheduled_start,
+                "scheduled_end": scheduled_end,
+                "operator_instructions": operator_instructions,
+                "planning_status": planning_status,
+                "effective_status": effective_status,
+                "has_runs": has_runs,
+                "created_at": created_at,
+                "created_by": created_by,
+                "created_by_object_id": created_by_object_id,
+                "archived_at": archived_at,
+                "version": version,
+                "people": people,
+                "type_refs": type_refs,
+                "task_name": task_name,
+                "variables": variables,
+                "recurring_acquisition_id": recurring_acquisition_id,
+                "occurrence_local_date": occurrence_local_date,
+                "warnings": warnings,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.acquisition_variable import AcquisitionVariable
+        from ..models.acquisition_warning import AcquisitionWarning
+        from ..models.person_assignment import PersonAssignment
+        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")
+
+        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"))
+
+        operator_instructions = d.pop("operator_instructions")
+
+        planning_status = PlanningStatus(d.pop("planning_status"))
+
+        effective_status = EffectiveStatus(d.pop("effective_status"))
+
+        has_runs = d.pop("has_runs")
+
+        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")
+
+        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)
+
+        def _parse_task_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        task_name = _parse_task_name(d.pop("task_name"))
+
+        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_recurring_acquisition_id(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        recurring_acquisition_id = _parse_recurring_acquisition_id(
+            d.pop("recurring_acquisition_id")
+        )
+
+        def _parse_occurrence_local_date(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)
+
+        occurrence_local_date = _parse_occurrence_local_date(d.pop("occurrence_local_date"))
+
+        warnings = []
+        _warnings = d.pop("warnings")
+        for warnings_item_data in _warnings:
+            warnings_item = AcquisitionWarning.from_dict(warnings_item_data)
+
+            warnings.append(warnings_item)
+
+        scheduled_acquisition_response = cls(
+            id=id,
+            subject_id=subject_id,
+            instrument_id=instrument_id,
+            project_id=project_id,
+            scheduled_start=scheduled_start,
+            scheduled_end=scheduled_end,
+            operator_instructions=operator_instructions,
+            planning_status=planning_status,
+            effective_status=effective_status,
+            has_runs=has_runs,
+            created_at=created_at,
+            created_by=created_by,
+            created_by_object_id=created_by_object_id,
+            archived_at=archived_at,
+            version=version,
+            people=people,
+            type_refs=type_refs,
+            task_name=task_name,
+            variables=variables,
+            recurring_acquisition_id=recurring_acquisition_id,
+            occurrence_local_date=occurrence_local_date,
+            warnings=warnings,
+        )
+
+        scheduled_acquisition_response.additional_properties = d
+        return scheduled_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/set_planning_status_request.py

@@ -0,0 +1,90 @@
+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.planning_status import PlanningStatus
+from ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="SetPlanningStatusRequest")
+
+
+@_attrs_define
+class SetPlanningStatusRequest:
+    """Set the hand-set disposition of a scheduled acquisition.
+
+    Attributes:
+        planning_status (PlanningStatus): A planned slot's own disposition, set by people (knowledge/decisions/0013).
+        expected_version (int | None | Unset): The `version` the client last read. When given and stale, the change is
+            rejected with 409 `version_conflict` instead of overwriting another edit.
+    """
+
+    planning_status: PlanningStatus
+    expected_version: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        planning_status = self.planning_status.value
+
+        expected_version: int | None | Unset
+        if isinstance(self.expected_version, Unset):
+            expected_version = UNSET
+        else:
+            expected_version = self.expected_version
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "planning_status": planning_status,
+            }
+        )
+        if expected_version is not UNSET:
+            field_dict["expected_version"] = expected_version
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        planning_status = PlanningStatus(d.pop("planning_status"))
+
+        def _parse_expected_version(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        expected_version = _parse_expected_version(d.pop("expected_version", UNSET))
+
+        set_planning_status_request = cls(
+            planning_status=planning_status,
+            expected_version=expected_version,
+        )
+
+        set_planning_status_request.additional_properties = d
+        return set_planning_status_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/settings_selector.py

@@ -0,0 +1,138 @@
+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.resolution_mode import ResolutionMode
+from ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="SettingsSelector")
+
+
+@_attrs_define
+class SettingsSelector:
+    """A settings selection rule for one acquisition type.
+
+    Attributes:
+        acquisition_type (str): Acquisition type key, e.g. `fip`.
+        resolution_mode (ResolutionMode): How a scheduled acquisition chooses its settings version for one acquisition
+            type.
+        pinned_settings_id (int | None | Unset): Required for `pinned`; otherwise null.
+        discriminator_field (None | str | Unset): Required for `discriminator`; one of the type's filter fields.
+        discriminator_value (None | str | Unset): Required for `discriminator`.
+    """
+
+    acquisition_type: str
+    resolution_mode: ResolutionMode
+    pinned_settings_id: int | None | Unset = UNSET
+    discriminator_field: None | str | Unset = UNSET
+    discriminator_value: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        acquisition_type = self.acquisition_type
+
+        resolution_mode = self.resolution_mode.value
+
+        pinned_settings_id: int | None | Unset
+        if isinstance(self.pinned_settings_id, Unset):
+            pinned_settings_id = UNSET
+        else:
+            pinned_settings_id = self.pinned_settings_id
+
+        discriminator_field: None | str | Unset
+        if isinstance(self.discriminator_field, Unset):
+            discriminator_field = UNSET
+        else:
+            discriminator_field = self.discriminator_field
+
+        discriminator_value: None | str | Unset
+        if isinstance(self.discriminator_value, Unset):
+            discriminator_value = UNSET
+        else:
+            discriminator_value = self.discriminator_value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "acquisition_type": acquisition_type,
+                "resolution_mode": resolution_mode,
+            }
+        )
+        if pinned_settings_id is not UNSET:
+            field_dict["pinned_settings_id"] = pinned_settings_id
+        if discriminator_field is not UNSET:
+            field_dict["discriminator_field"] = discriminator_field
+        if discriminator_value is not UNSET:
+            field_dict["discriminator_value"] = discriminator_value
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        acquisition_type = d.pop("acquisition_type")
+
+        resolution_mode = ResolutionMode(d.pop("resolution_mode"))
+
+        def _parse_pinned_settings_id(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        pinned_settings_id = _parse_pinned_settings_id(d.pop("pinned_settings_id", UNSET))
+
+        def _parse_discriminator_field(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        discriminator_field = _parse_discriminator_field(d.pop("discriminator_field", UNSET))
+
+        def _parse_discriminator_value(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        discriminator_value = _parse_discriminator_value(d.pop("discriminator_value", UNSET))
+
+        settings_selector = cls(
+            acquisition_type=acquisition_type,
+            resolution_mode=resolution_mode,
+            pinned_settings_id=pinned_settings_id,
+            discriminator_field=discriminator_field,
+            discriminator_value=discriminator_value,
+        )
+
+        settings_selector.additional_properties = d
+        return settings_selector
+
+    @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/skipped_occurrence.py

@@ -0,0 +1,85 @@
+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.recurrence_exception_kind import RecurrenceExceptionKind
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="SkippedOccurrence")
+
+
+@_attrs_define
+class SkippedOccurrence:
+    """An occurrence the rule produced a date for but that cannot be scheduled.
+
+    Attributes:
+        occurrence_local_date (datetime.date): Calendar date, e.g. 2026-10-15.
+        reason (RecurrenceExceptionKind): Why an occurrence has no acquisition, or what happened to it afterwards.
+        message (str): Human-readable explanation.
+    """
+
+    occurrence_local_date: datetime.date
+    reason: RecurrenceExceptionKind
+    message: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        occurrence_local_date = self.occurrence_local_date.isoformat()
+
+        reason = self.reason.value
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "occurrence_local_date": occurrence_local_date,
+                "reason": reason,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        occurrence_local_date = datetime.date.fromisoformat(d.pop("occurrence_local_date"))
+
+        reason = RecurrenceExceptionKind(d.pop("reason"))
+
+        message = d.pop("message")
+
+        skipped_occurrence = cls(
+            occurrence_local_date=occurrence_local_date,
+            reason=reason,
+            message=message,
+        )
+
+        skipped_occurrence.additional_properties = d
+        return skipped_occurrence
+
+    @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