docket-client 0.3.2__py3-none-any.whl

docket/models/split_preview_response.py

@@ -0,0 +1,129 @@
+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.kept_occurrence import KeptOccurrence
+    from ..models.occurrence_preview import OccurrencePreview
+    from ..models.skipped_occurrence import SkippedOccurrence
+
+
+T = TypeVar("T", bound="SplitPreviewResponse")
+
+
+@_attrs_define
+class SplitPreviewResponse:
+    """What splitting would do. Nothing was written.
+
+    Attributes:
+        occurrences (list[OccurrencePreview]): Occurrences the new series would create, in order.
+        skipped (list[SkippedOccurrence]): Dates the new series would not create: DST skips, `kept_from_previous` and
+            `removed_in_previous`.
+        replaced (list[int]): Ids of old occurrences on or after `effective_date` that would be archived.
+        kept (list[KeptOccurrence]): Old occurrences on or after `effective_date` that stay, with the reason.
+    """
+
+    occurrences: list[OccurrencePreview]
+    skipped: list[SkippedOccurrence]
+    replaced: list[int]
+    kept: list[KeptOccurrence]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.kept_occurrence import KeptOccurrence
+        from ..models.occurrence_preview import OccurrencePreview
+        from ..models.skipped_occurrence import SkippedOccurrence
+
+        occurrences = []
+        for occurrences_item_data in self.occurrences:
+            occurrences_item = occurrences_item_data.to_dict()
+            occurrences.append(occurrences_item)
+
+        skipped = []
+        for skipped_item_data in self.skipped:
+            skipped_item = skipped_item_data.to_dict()
+            skipped.append(skipped_item)
+
+        replaced = self.replaced
+
+        kept = []
+        for kept_item_data in self.kept:
+            kept_item = kept_item_data.to_dict()
+            kept.append(kept_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "occurrences": occurrences,
+                "skipped": skipped,
+                "replaced": replaced,
+                "kept": kept,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.kept_occurrence import KeptOccurrence
+        from ..models.occurrence_preview import OccurrencePreview
+        from ..models.skipped_occurrence import SkippedOccurrence
+
+        d = dict(src_dict)
+        occurrences = []
+        _occurrences = d.pop("occurrences")
+        for occurrences_item_data in _occurrences:
+            occurrences_item = OccurrencePreview.from_dict(occurrences_item_data)
+
+            occurrences.append(occurrences_item)
+
+        skipped = []
+        _skipped = d.pop("skipped")
+        for skipped_item_data in _skipped:
+            skipped_item = SkippedOccurrence.from_dict(skipped_item_data)
+
+            skipped.append(skipped_item)
+
+        replaced = cast(list[int], d.pop("replaced"))
+
+        kept = []
+        _kept = d.pop("kept")
+        for kept_item_data in _kept:
+            kept_item = KeptOccurrence.from_dict(kept_item_data)
+
+            kept.append(kept_item)
+
+        split_preview_response = cls(
+            occurrences=occurrences,
+            skipped=skipped,
+            replaced=replaced,
+            kept=kept,
+        )
+
+        split_preview_response.additional_properties = d
+        return split_preview_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/split_recurring_acquisition_request.py

@@ -0,0 +1,261 @@
+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.recurrence_rule import RecurrenceRule
+    from ..models.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="SplitRecurringAcquisitionRequest")
+
+
+@_attrs_define
+class SplitRecurringAcquisitionRequest:
+    """Edit a series from a date onward: end the old series the day before
+    `effective_date` and start a new one from it. Carries the complete new definition (the same fields as
+    CreateRecurringAcquisitionRequest), not a patch; clients prefill it from the old one.
+    `rule.start_date` must equal `effective_date`. For a `count` rule, `count` is the number
+    of occurrences of the new part.
+
+        Attributes:
+            expected_version (int): The old definition's `version`. A stale value is rejected with 409 `version_conflict`.
+            effective_date (datetime.date): Calendar date, e.g. 2026-10-15.
+            subject_id (str): Subject; validated against the metadata service.
+            instrument_id (str): Instrument; must be in the synced list.
+            project_id (str): Project; must be in the synced list.
+            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 | 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.
+    """
+
+    expected_version: int
+    effective_date: datetime.date
+    subject_id: str
+    instrument_id: str
+    project_id: str
+    rule: RecurrenceRule
+    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.recurrence_rule import RecurrenceRule
+        from ..models.settings_selector import SettingsSelector
+
+        expected_version = self.expected_version
+
+        effective_date = self.effective_date.isoformat()
+
+        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: 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(
+            {
+                "expected_version": expected_version,
+                "effective_date": effective_date,
+                "subject_id": subject_id,
+                "instrument_id": instrument_id,
+                "project_id": project_id,
+                "rule": rule,
+            }
+        )
+        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.recurrence_rule import RecurrenceRule
+        from ..models.settings_selector import SettingsSelector
+
+        d = dict(src_dict)
+        expected_version = d.pop("expected_version")
+
+        effective_date = datetime.date.fromisoformat(d.pop("effective_date"))
+
+        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", 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))
+
+        split_recurring_acquisition_request = cls(
+            expected_version=expected_version,
+            effective_date=effective_date,
+            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,
+        )
+
+        split_recurring_acquisition_request.additional_properties = d
+        return split_recurring_acquisition_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

docket/models/split_recurring_acquisition_response.py

@@ -0,0 +1,159 @@
+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.kept_occurrence import KeptOccurrence
+    from ..models.occurrence_warnings import OccurrenceWarnings
+    from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+    from ..models.skipped_occurrence import SkippedOccurrence
+
+
+T = TypeVar("T", bound="SplitRecurringAcquisitionResponse")
+
+
+@_attrs_define
+class SplitRecurringAcquisitionResponse:
+    """A series split in two.
+
+    Attributes:
+        definition (RecurringAcquisitionResponse): A recurring definition: scheduling intent, from which occurrences
+            were materialized.
+        previous (RecurringAcquisitionResponse): A recurring definition: scheduling intent, from which occurrences were
+            materialized.
+        occurrence_ids (list[int]): Ids of the occurrences created for the new series, in order.
+        replaced (list[int]): Ids of old occurrences archived by the split (each recorded as an `archived` exception).
+        kept (list[KeptOccurrence]): Old occurrences on or after `effective_date` left untouched.
+        skipped (list[SkippedOccurrence]): Dates the new series did not create: DST skips, `kept_from_previous` and
+            `removed_in_previous`.
+        warnings (list[OccurrenceWarnings]): Overlap warnings per new occurrence; replaced occurrences are not counted
+            as overlaps.
+    """
+
+    definition: RecurringAcquisitionResponse
+    previous: RecurringAcquisitionResponse
+    occurrence_ids: list[int]
+    replaced: list[int]
+    kept: list[KeptOccurrence]
+    skipped: list[SkippedOccurrence]
+    warnings: list[OccurrenceWarnings]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.kept_occurrence import KeptOccurrence
+        from ..models.occurrence_warnings import OccurrenceWarnings
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+        from ..models.skipped_occurrence import SkippedOccurrence
+
+        definition = self.definition.to_dict()
+
+        previous = self.previous.to_dict()
+
+        occurrence_ids = self.occurrence_ids
+
+        replaced = self.replaced
+
+        kept = []
+        for kept_item_data in self.kept:
+            kept_item = kept_item_data.to_dict()
+            kept.append(kept_item)
+
+        skipped = []
+        for skipped_item_data in self.skipped:
+            skipped_item = skipped_item_data.to_dict()
+            skipped.append(skipped_item)
+
+        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(
+            {
+                "definition": definition,
+                "previous": previous,
+                "occurrence_ids": occurrence_ids,
+                "replaced": replaced,
+                "kept": kept,
+                "skipped": skipped,
+                "warnings": warnings,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.kept_occurrence import KeptOccurrence
+        from ..models.occurrence_warnings import OccurrenceWarnings
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+        from ..models.skipped_occurrence import SkippedOccurrence
+
+        d = dict(src_dict)
+        definition = RecurringAcquisitionResponse.from_dict(d.pop("definition"))
+
+        previous = RecurringAcquisitionResponse.from_dict(d.pop("previous"))
+
+        occurrence_ids = cast(list[int], d.pop("occurrence_ids"))
+
+        replaced = cast(list[int], d.pop("replaced"))
+
+        kept = []
+        _kept = d.pop("kept")
+        for kept_item_data in _kept:
+            kept_item = KeptOccurrence.from_dict(kept_item_data)
+
+            kept.append(kept_item)
+
+        skipped = []
+        _skipped = d.pop("skipped")
+        for skipped_item_data in _skipped:
+            skipped_item = SkippedOccurrence.from_dict(skipped_item_data)
+
+            skipped.append(skipped_item)
+
+        warnings = []
+        _warnings = d.pop("warnings")
+        for warnings_item_data in _warnings:
+            warnings_item = OccurrenceWarnings.from_dict(warnings_item_data)
+
+            warnings.append(warnings_item)
+
+        split_recurring_acquisition_response = cls(
+            definition=definition,
+            previous=previous,
+            occurrence_ids=occurrence_ids,
+            replaced=replaced,
+            kept=kept,
+            skipped=skipped,
+            warnings=warnings,
+        )
+
+        split_recurring_acquisition_response.additional_properties = d
+        return split_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/start_run_request.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
+
+from ..models.run_origin import RunOrigin
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="StartRunRequest")
+
+
+@_attrs_define
+class StartRunRequest:
+    """Start a run of a scheduled acquisition.
+
+    Attributes:
+        origin (RunOrigin | Unset): Who started a run: the rig software, or a person recording it by hand.
+    """
+
+    origin: RunOrigin | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        origin: str | Unset = UNSET
+        if not isinstance(self.origin, Unset):
+            origin = self.origin.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if origin is not UNSET:
+            field_dict["origin"] = origin
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _origin = d.pop("origin", UNSET)
+        origin: RunOrigin | Unset
+        if isinstance(_origin, Unset):
+            origin = UNSET
+        else:
+            origin = RunOrigin(_origin)
+
+        start_run_request = cls(
+            origin=origin,
+        )
+
+        start_run_request.additional_properties = d
+        return start_run_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