docket-client 0.3.2__py3-none-any.whl

docket/models/create_api_token_request.py

@@ -0,0 +1,97 @@
+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
+
+
+T = TypeVar("T", bound="CreateApiTokenRequest")
+
+
+@_attrs_define
+class CreateApiTokenRequest:
+    """Issues an API token.
+
+    Attributes:
+        principal_object_id (str): The principal it acts as. Not a bootstrap admin.
+        name (str): What it is for.
+        expires_in_days (int | None | Unset): Lifetime in days; default 90, at most `Auth:ApiTokens:MaxLifetimeDays`
+            (default 365).
+    """
+
+    principal_object_id: str
+    name: str
+    expires_in_days: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        principal_object_id = self.principal_object_id
+
+        name = self.name
+
+        expires_in_days: int | None | Unset
+        if isinstance(self.expires_in_days, Unset):
+            expires_in_days = UNSET
+        else:
+            expires_in_days = self.expires_in_days
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "principal_object_id": principal_object_id,
+                "name": name,
+            }
+        )
+        if expires_in_days is not UNSET:
+            field_dict["expires_in_days"] = expires_in_days
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        principal_object_id = d.pop("principal_object_id")
+
+        name = d.pop("name")
+
+        def _parse_expires_in_days(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        expires_in_days = _parse_expires_in_days(d.pop("expires_in_days", UNSET))
+
+        create_api_token_request = cls(
+            principal_object_id=principal_object_id,
+            name=name,
+            expires_in_days=expires_in_days,
+        )
+
+        create_api_token_request.additional_properties = d
+        return create_api_token_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_application_principal_request.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+
+T = TypeVar("T", bound="CreateApplicationPrincipalRequest")
+
+
+@_attrs_define
+class CreateApplicationPrincipalRequest:
+    """Creates a Docket-local application principal: a rig or script with no Entra registration.
+
+    Attributes:
+        display_name (str): A label, e.g. "BEH.B-Box1 rig".
+    """
+
+    display_name: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        display_name = self.display_name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "display_name": display_name,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        display_name = d.pop("display_name")
+
+        create_application_principal_request = cls(
+            display_name=display_name,
+        )
+
+        create_application_principal_request.additional_properties = d
+        return create_application_principal_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_personal_api_token_request.py

@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.access_role_nullable_type_1 import AccessRoleNullableType1
+from ..models.access_role_nullable_type_2_type_1 import AccessRoleNullableType2Type1
+from ..models.access_role_nullable_type_3_type_1 import AccessRoleNullableType3Type1
+from ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="CreatePersonalApiTokenRequest")
+
+
+@_attrs_define
+class CreatePersonalApiTokenRequest:
+    """Creates a personal API token for the signed-in caller.
+
+    Attributes:
+        name (str): What it is for.
+        expires_in_days (int | None | Unset): Lifetime in days; default 30, at most
+            `Auth:ApiTokens:PersonalMaxLifetimeDays` (default 90). `GET /api/v1/me` lists the lifetimes to offer.
+        max_role (AccessRoleNullableType1 | AccessRoleNullableType2Type1 | AccessRoleNullableType3Type1 | None | Unset):
+    """
+
+    name: str
+    expires_in_days: int | None | Unset = UNSET
+    max_role: (
+        AccessRoleNullableType1
+        | AccessRoleNullableType2Type1
+        | AccessRoleNullableType3Type1
+        | None
+        | Unset
+    ) = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        expires_in_days: int | None | Unset
+        if isinstance(self.expires_in_days, Unset):
+            expires_in_days = UNSET
+        else:
+            expires_in_days = self.expires_in_days
+
+        max_role: None | str | Unset
+        if isinstance(self.max_role, Unset):
+            max_role = UNSET
+        elif isinstance(self.max_role, AccessRoleNullableType1):
+            max_role = self.max_role.value
+        elif isinstance(self.max_role, AccessRoleNullableType2Type1):
+            max_role = self.max_role.value
+        elif isinstance(self.max_role, AccessRoleNullableType3Type1):
+            max_role = self.max_role.value
+        else:
+            max_role = self.max_role
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if expires_in_days is not UNSET:
+            field_dict["expires_in_days"] = expires_in_days
+        if max_role is not UNSET:
+            field_dict["max_role"] = max_role
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        def _parse_expires_in_days(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        expires_in_days = _parse_expires_in_days(d.pop("expires_in_days", UNSET))
+
+        def _parse_max_role(
+            data: object,
+        ) -> (
+            AccessRoleNullableType1
+            | AccessRoleNullableType2Type1
+            | AccessRoleNullableType3Type1
+            | None
+            | Unset
+        ):
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_1 = AccessRoleNullableType1(data)
+
+                return componentsschemas_access_role_nullable_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_2_type_1 = AccessRoleNullableType2Type1(
+                    data
+                )
+
+                return componentsschemas_access_role_nullable_type_2_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                componentsschemas_access_role_nullable_type_3_type_1 = AccessRoleNullableType3Type1(
+                    data
+                )
+
+                return componentsschemas_access_role_nullable_type_3_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(
+                AccessRoleNullableType1
+                | AccessRoleNullableType2Type1
+                | AccessRoleNullableType3Type1
+                | None
+                | Unset,
+                data,
+            )
+
+        max_role = _parse_max_role(d.pop("max_role", UNSET))
+
+        create_personal_api_token_request = cls(
+            name=name,
+            expires_in_days=expires_in_days,
+            max_role=max_role,
+        )
+
+        create_personal_api_token_request.additional_properties = d
+        return create_personal_api_token_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_recurring_acquisition_request.py

@@ -0,0 +1,269 @@
+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.recurrence_rule import RecurrenceRule
+    from ..models.settings_selector import SettingsSelector
+
+
+T = TypeVar("T", bound="CreateRecurringAcquisitionRequest")
+
+
+@_attrs_define
+class CreateRecurringAcquisitionRequest:
+    """Plan a finite series. The acquisition fields mean what they do on
+    CreateScheduledAcquisitionRequest and are copied onto every occurrence.
+
+        Attributes:
+            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.
+            source_acquisition_id (int | None | Unset): Start the series from an existing scheduled session: that session
+                becomes the series' first occurrence instead of
+                a new one being created for its date. It must exist (404), not be archived (409 `acquisition_archived`), not
+                belong to a series (409 `acquisition_in_series`) and have no runs (409 `acquisition_has_runs`). Its subject and
+                instrument must be this request's (422 `subject_id` / `instrument_id`, compared as canonical ids). Its local
+                date in the rule's zone must equal `rule.start_date` and be a date the rule selects (422). It keeps its own
+                times, people, settings and variables; only the new occurrences follow the rule and these fields. An `edited`
+                exception is recorded for it when its times or any of those fields differ from the series', so a later split
+                keeps it.
+    """
+
+    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
+    source_acquisition_id: int | 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
+
+        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
+
+        source_acquisition_id: int | None | Unset
+        if isinstance(self.source_acquisition_id, Unset):
+            source_acquisition_id = UNSET
+        else:
+            source_acquisition_id = self.source_acquisition_id
+
+        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,
+                "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
+        if source_acquisition_id is not UNSET:
+            field_dict["source_acquisition_id"] = source_acquisition_id
+
+        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)
+        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))
+
+        def _parse_source_acquisition_id(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        source_acquisition_id = _parse_source_acquisition_id(d.pop("source_acquisition_id", UNSET))
+
+        create_recurring_acquisition_request = cls(
+            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,
+            source_acquisition_id=source_acquisition_id,
+        )
+
+        create_recurring_acquisition_request.additional_properties = d
+        return create_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/create_role_assignment_request.py

@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, BinaryIO, TextIO, TYPE_CHECKING, Generator
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+from ..models.access_role import AccessRole
+from ..types import UNSET, Unset
+from typing import cast
+
+
+T = TypeVar("T", bound="CreateRoleAssignmentRequest")
+
+
+@_attrs_define
+class CreateRoleAssignmentRequest:
+    """Grants a role.
+
+    Attributes:
+        principal_object_id (str): A known principal (one who has signed in, or was added).
+        role (AccessRole): A role Docket grants. Roles live in Docket's database; Entra only proves
+            who the caller is, and the token's own `roles` claim is ignored.
+        scope (None | str | Unset): For acquisition settings maintainers: an acquisition-type key, or omitted for all
+            acquisition types. Must be omitted for other roles.
+    """
+
+    principal_object_id: str
+    role: AccessRole
+    scope: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        principal_object_id = self.principal_object_id
+
+        role = self.role.value
+
+        scope: None | str | Unset
+        if isinstance(self.scope, Unset):
+            scope = UNSET
+        else:
+            scope = self.scope
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "principal_object_id": principal_object_id,
+                "role": role,
+            }
+        )
+        if scope is not UNSET:
+            field_dict["scope"] = scope
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        principal_object_id = d.pop("principal_object_id")
+
+        role = AccessRole(d.pop("role"))
+
+        def _parse_scope(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        scope = _parse_scope(d.pop("scope", UNSET))
+
+        create_role_assignment_request = cls(
+            principal_object_id=principal_object_id,
+            role=role,
+            scope=scope,
+        )
+
+        create_role_assignment_request.additional_properties = d
+        return create_role_assignment_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