docket-client 0.3.2__py3-none-any.whl

docket/models/get_resolved_settings_response_200.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
+
+from typing import cast
+
+if TYPE_CHECKING:
+    from ..models.resolved_settings import ResolvedSettings
+
+
+T = TypeVar("T", bound="GetResolvedSettingsResponse200")
+
+
+@_attrs_define
+class GetResolvedSettingsResponse200:
+    """ """
+
+    additional_properties: dict[str, ResolvedSettings] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.resolved_settings import ResolvedSettings
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.resolved_settings import ResolvedSettings
+
+        d = dict(src_dict)
+        get_resolved_settings_response_200 = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = ResolvedSettings.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        get_resolved_settings_response_200.additional_properties = additional_properties
+        return get_resolved_settings_response_200
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> ResolvedSettings:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: ResolvedSettings) -> 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/held_role_response.py

@@ -0,0 +1,116 @@
+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 ..models.role_origin import RoleOrigin
+from typing import cast
+
+
+T = TypeVar("T", bound="HeldRoleResponse")
+
+
+@_attrs_define
+class HeldRoleResponse:
+    """A role a principal holds.
+
+    Attributes:
+        assignment_id (int | None): The assignment to archive to remove it; null for bootstrap.
+        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): Acquisition-type key for an acquisition settings maintainer; null means all acquisition
+            types (or not applicable).
+        origin (RoleOrigin): Where a held role comes from.
+        bootstrap (bool): True when it comes from server configuration and cannot be removed here.
+    """
+
+    assignment_id: int | None
+    role: AccessRole
+    scope: None | str
+    origin: RoleOrigin
+    bootstrap: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        assignment_id: int | None
+        assignment_id = self.assignment_id
+
+        role = self.role.value
+
+        scope: None | str
+        scope = self.scope
+
+        origin = self.origin.value
+
+        bootstrap = self.bootstrap
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "assignment_id": assignment_id,
+                "role": role,
+                "scope": scope,
+                "origin": origin,
+                "bootstrap": bootstrap,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_assignment_id(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        assignment_id = _parse_assignment_id(d.pop("assignment_id"))
+
+        role = AccessRole(d.pop("role"))
+
+        def _parse_scope(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        scope = _parse_scope(d.pop("scope"))
+
+        origin = RoleOrigin(d.pop("origin"))
+
+        bootstrap = d.pop("bootstrap")
+
+        held_role_response = cls(
+            assignment_id=assignment_id,
+            role=role,
+            scope=scope,
+            origin=origin,
+            bootstrap=bootstrap,
+        )
+
+        held_role_response.additional_properties = d
+        return held_role_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/http_validation_problem_details.py

@@ -0,0 +1,204 @@
+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.http_validation_problem_details_errors import HttpValidationProblemDetailsErrors
+
+
+T = TypeVar("T", bound="HttpValidationProblemDetails")
+
+
+@_attrs_define
+class HttpValidationProblemDetails:
+    """
+    Attributes:
+        code (str): Stable machine-readable error code, e.g. not_found, validation_failed, version_conflict,
+            settings_not_available.
+        request_id (str): Correlation id of the request (the X-Request-Id response header); quote it when reporting a
+            problem.
+        type_ (None | str | Unset):
+        title (None | str | Unset):
+        status (int | None | Unset):
+        detail (None | str | Unset):
+        instance (None | str | Unset):
+        errors (HttpValidationProblemDetailsErrors | Unset):
+    """
+
+    code: str
+    request_id: str
+    type_: None | str | Unset = UNSET
+    title: None | str | Unset = UNSET
+    status: int | None | Unset = UNSET
+    detail: None | str | Unset = UNSET
+    instance: None | str | Unset = UNSET
+    errors: HttpValidationProblemDetailsErrors | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.http_validation_problem_details_errors import (
+            HttpValidationProblemDetailsErrors,
+        )
+
+        code = self.code
+
+        request_id = self.request_id
+
+        type_: None | str | Unset
+        if isinstance(self.type_, Unset):
+            type_ = UNSET
+        else:
+            type_ = self.type_
+
+        title: None | str | Unset
+        if isinstance(self.title, Unset):
+            title = UNSET
+        else:
+            title = self.title
+
+        status: int | None | Unset
+        if isinstance(self.status, Unset):
+            status = UNSET
+        else:
+            status = self.status
+
+        detail: None | str | Unset
+        if isinstance(self.detail, Unset):
+            detail = UNSET
+        else:
+            detail = self.detail
+
+        instance: None | str | Unset
+        if isinstance(self.instance, Unset):
+            instance = UNSET
+        else:
+            instance = self.instance
+
+        errors: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.errors, Unset):
+            errors = self.errors.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "code": code,
+                "request_id": request_id,
+            }
+        )
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if title is not UNSET:
+            field_dict["title"] = title
+        if status is not UNSET:
+            field_dict["status"] = status
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+        if instance is not UNSET:
+            field_dict["instance"] = instance
+        if errors is not UNSET:
+            field_dict["errors"] = errors
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.http_validation_problem_details_errors import (
+            HttpValidationProblemDetailsErrors,
+        )
+
+        d = dict(src_dict)
+        code = d.pop("code")
+
+        request_id = d.pop("request_id")
+
+        def _parse_type_(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        type_ = _parse_type_(d.pop("type", UNSET))
+
+        def _parse_title(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        title = _parse_title(d.pop("title", UNSET))
+
+        def _parse_status(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        status = _parse_status(d.pop("status", UNSET))
+
+        def _parse_detail(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        detail = _parse_detail(d.pop("detail", UNSET))
+
+        def _parse_instance(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        instance = _parse_instance(d.pop("instance", UNSET))
+
+        _errors = d.pop("errors", UNSET)
+        errors: HttpValidationProblemDetailsErrors | Unset
+        if isinstance(_errors, Unset):
+            errors = UNSET
+        else:
+            errors = HttpValidationProblemDetailsErrors.from_dict(_errors)
+
+        http_validation_problem_details = cls(
+            code=code,
+            request_id=request_id,
+            type_=type_,
+            title=title,
+            status=status,
+            detail=detail,
+            instance=instance,
+            errors=errors,
+        )
+
+        http_validation_problem_details.additional_properties = d
+        return http_validation_problem_details
+
+    @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/http_validation_problem_details_errors.py

@@ -0,0 +1,59 @@
+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
+
+
+T = TypeVar("T", bound="HttpValidationProblemDetailsErrors")
+
+
+@_attrs_define
+class HttpValidationProblemDetailsErrors:
+    """ """
+
+    additional_properties: dict[str, list[str]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        http_validation_problem_details_errors = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = cast(list[str], prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        http_validation_problem_details_errors.additional_properties = additional_properties
+        return http_validation_problem_details_errors
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str]) -> 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/instrument_response.py

@@ -0,0 +1,91 @@
+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
+
+
+T = TypeVar("T", bound="InstrumentResponse")
+
+
+@_attrs_define
+class InstrumentResponse:
+    """
+    Attributes:
+        id (str):
+        hostname (str):
+        rig_id (str):
+        synced_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+    """
+
+    id: str
+    hostname: str
+    rig_id: str
+    synced_at: datetime.datetime
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        hostname = self.hostname
+
+        rig_id = self.rig_id
+
+        synced_at = self.synced_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "hostname": hostname,
+                "rig_id": rig_id,
+                "synced_at": synced_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        hostname = d.pop("hostname")
+
+        rig_id = d.pop("rig_id")
+
+        synced_at = datetime.datetime.fromisoformat(d.pop("synced_at"))
+
+        instrument_response = cls(
+            id=id,
+            hostname=hostname,
+            rig_id=rig_id,
+            synced_at=synced_at,
+        )
+
+        instrument_response.additional_properties = d
+        return instrument_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/kept_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.kept_occurrence_reason import KeptOccurrenceReason
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="KeptOccurrence")
+
+
+@_attrs_define
+class KeptOccurrence:
+    """An occurrence of the old series, on or after the split date, that the split leaves alone.
+
+    Attributes:
+        scheduled_acquisition_id (int): The occurrence.
+        occurrence_local_date (datetime.date): Calendar date, e.g. 2026-10-15.
+        reason (KeptOccurrenceReason): Why an occurrence of the previous series survives a split.
+    """
+
+    scheduled_acquisition_id: int
+    occurrence_local_date: datetime.date
+    reason: KeptOccurrenceReason
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        scheduled_acquisition_id = self.scheduled_acquisition_id
+
+        occurrence_local_date = self.occurrence_local_date.isoformat()
+
+        reason = self.reason.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "scheduled_acquisition_id": scheduled_acquisition_id,
+                "occurrence_local_date": occurrence_local_date,
+                "reason": reason,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        scheduled_acquisition_id = d.pop("scheduled_acquisition_id")
+
+        occurrence_local_date = datetime.date.fromisoformat(d.pop("occurrence_local_date"))
+
+        reason = KeptOccurrenceReason(d.pop("reason"))
+
+        kept_occurrence = cls(
+            scheduled_acquisition_id=scheduled_acquisition_id,
+            occurrence_local_date=occurrence_local_date,
+            reason=reason,
+        )
+
+        kept_occurrence.additional_properties = d
+        return kept_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

docket/models/kept_occurrence_reason.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class KeptOccurrenceReason(str, Enum):
+    EDITED = "edited"
+    HAS_RUN = "has_run"
+    STARTED = "started"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/list_active_acquisitions_effective_status_item.py

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

docket/models/list_scheduled_acquisitions_planning_status.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class ListScheduledAcquisitionsPlanningStatus(str, Enum):
+    CANCELLED = "cancelled"
+    FAILED = "failed"
+    SCHEDULED = "scheduled"
+    SUCCEEDED = "succeeded"
+
+    def __str__(self) -> str:
+        return str(self.value)