docket-client 0.3.2__py3-none-any.whl

docket/models/principal_response.py

@@ -0,0 +1,216 @@
+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.principal_kind import PrincipalKind
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+if TYPE_CHECKING:
+    from ..models.held_role_response import HeldRoleResponse
+
+
+T = TypeVar("T", bound="PrincipalResponse")
+
+
+@_attrs_define
+class PrincipalResponse:
+    """A person or application Docket knows about.
+
+    Attributes:
+        object_id (str): Directory object id (the identity key).
+        kind (PrincipalKind): What kind of directory principal a role is held by.
+        display_name (str): For display only.
+        user_principal_name (None | str): Sign-in name; for display only, never an identity key. Null for applications.
+        first_seen_at (datetime.datetime | None):
+        last_seen_at (datetime.datetime | None):
+        is_bootstrap (bool): True for object ids in `Auth:BootstrapAdmins`: always Admin, set in server configuration.
+        roles (list[HeldRoleResponse]): Their roles: active assignments, plus Admin when bootstrap. The default role is
+            not listed.
+        last_interactive_sign_in_at (datetime.datetime | None | Unset): Last time they presented an Entra token
+            themselves (API tokens do not count), accurate to a few minutes. Their API tokens work only while this is
+            recent.
+    """
+
+    object_id: str
+    kind: PrincipalKind
+    display_name: str
+    user_principal_name: None | str
+    first_seen_at: datetime.datetime | None
+    last_seen_at: datetime.datetime | None
+    is_bootstrap: bool
+    roles: list[HeldRoleResponse]
+    last_interactive_sign_in_at: datetime.datetime | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.held_role_response import HeldRoleResponse
+
+        object_id = self.object_id
+
+        kind = self.kind.value
+
+        display_name = self.display_name
+
+        user_principal_name: None | str
+        user_principal_name = self.user_principal_name
+
+        first_seen_at: None | str
+        if isinstance(self.first_seen_at, datetime.datetime):
+            first_seen_at = self.first_seen_at.isoformat()
+        else:
+            first_seen_at = self.first_seen_at
+
+        last_seen_at: None | str
+        if isinstance(self.last_seen_at, datetime.datetime):
+            last_seen_at = self.last_seen_at.isoformat()
+        else:
+            last_seen_at = self.last_seen_at
+
+        is_bootstrap = self.is_bootstrap
+
+        roles = []
+        for roles_item_data in self.roles:
+            roles_item = roles_item_data.to_dict()
+            roles.append(roles_item)
+
+        last_interactive_sign_in_at: None | str | Unset
+        if isinstance(self.last_interactive_sign_in_at, Unset):
+            last_interactive_sign_in_at = UNSET
+        elif isinstance(self.last_interactive_sign_in_at, datetime.datetime):
+            last_interactive_sign_in_at = self.last_interactive_sign_in_at.isoformat()
+        else:
+            last_interactive_sign_in_at = self.last_interactive_sign_in_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "object_id": object_id,
+                "kind": kind,
+                "display_name": display_name,
+                "user_principal_name": user_principal_name,
+                "first_seen_at": first_seen_at,
+                "last_seen_at": last_seen_at,
+                "is_bootstrap": is_bootstrap,
+                "roles": roles,
+            }
+        )
+        if last_interactive_sign_in_at is not UNSET:
+            field_dict["last_interactive_sign_in_at"] = last_interactive_sign_in_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.held_role_response import HeldRoleResponse
+
+        d = dict(src_dict)
+        object_id = d.pop("object_id")
+
+        kind = PrincipalKind(d.pop("kind"))
+
+        display_name = d.pop("display_name")
+
+        def _parse_user_principal_name(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        user_principal_name = _parse_user_principal_name(d.pop("user_principal_name"))
+
+        def _parse_first_seen_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)
+
+        first_seen_at = _parse_first_seen_at(d.pop("first_seen_at"))
+
+        def _parse_last_seen_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)
+
+        last_seen_at = _parse_last_seen_at(d.pop("last_seen_at"))
+
+        is_bootstrap = d.pop("is_bootstrap")
+
+        roles = []
+        _roles = d.pop("roles")
+        for roles_item_data in _roles:
+            roles_item = HeldRoleResponse.from_dict(roles_item_data)
+
+            roles.append(roles_item)
+
+        def _parse_last_interactive_sign_in_at(data: object) -> datetime.datetime | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_interactive_sign_in_at_type_1 = datetime.datetime.fromisoformat(data)
+
+                return last_interactive_sign_in_at_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.datetime | None | Unset, data)
+
+        last_interactive_sign_in_at = _parse_last_interactive_sign_in_at(
+            d.pop("last_interactive_sign_in_at", UNSET)
+        )
+
+        principal_response = cls(
+            object_id=object_id,
+            kind=kind,
+            display_name=display_name,
+            user_principal_name=user_principal_name,
+            first_seen_at=first_seen_at,
+            last_seen_at=last_seen_at,
+            is_bootstrap=is_bootstrap,
+            roles=roles,
+            last_interactive_sign_in_at=last_interactive_sign_in_at,
+        )
+
+        principal_response.additional_properties = d
+        return principal_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/problem_details.py

@@ -0,0 +1,177 @@
+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="ProblemDetails")
+
+
+@_attrs_define
+class ProblemDetails:
+    """
+    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):
+    """
+
+    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
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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
+
+        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
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        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))
+
+        problem_details = cls(
+            code=code,
+            request_id=request_id,
+            type_=type_,
+            title=title,
+            status=status,
+            detail=detail,
+            instance=instance,
+        )
+
+        problem_details.additional_properties = d
+        return 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/project_response.py

@@ -0,0 +1,75 @@
+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="ProjectResponse")
+
+
+@_attrs_define
+class ProjectResponse:
+    """
+    Attributes:
+        id (str):
+        synced_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+    """
+
+    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
+
+        synced_at = self.synced_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": 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")
+
+        synced_at = datetime.datetime.fromisoformat(d.pop("synced_at"))
+
+        project_response = cls(
+            id=id,
+            synced_at=synced_at,
+        )
+
+        project_response.additional_properties = d
+        return project_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/recurrence_exception_kind.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class RecurrenceExceptionKind(str, Enum):
+    ARCHIVED = "archived"
+    EDITED = "edited"
+    KEPT_FROM_PREVIOUS = "kept_from_previous"
+    REMOVED_IN_PREVIOUS = "removed_in_previous"
+    SKIPPED_DST_AMBIGUOUS = "skipped_dst_ambiguous"
+    SKIPPED_DST_GAP = "skipped_dst_gap"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/recurrence_exception_response.py

@@ -0,0 +1,103 @@
+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="RecurrenceExceptionResponse")
+
+
+@_attrs_define
+class RecurrenceExceptionResponse:
+    """A recorded exception to the rule.
+
+    Attributes:
+        occurrence_local_date (datetime.date): Calendar date, e.g. 2026-10-15.
+        kind (RecurrenceExceptionKind): Why an occurrence has no acquisition, or what happened to it afterwards.
+        scheduled_acquisition_id (int | None): The occurrence this is about; null for DST-skipped dates. For
+            `kept_from_previous` it is the
+            kept occurrence of the previous series.
+        created_at (datetime.datetime): UTC instant, ISO 8601 with offset, e.g. 2026-10-15T16:00:00Z.
+    """
+
+    occurrence_local_date: datetime.date
+    kind: RecurrenceExceptionKind
+    scheduled_acquisition_id: int | None
+    created_at: datetime.datetime
+    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()
+
+        kind = self.kind.value
+
+        scheduled_acquisition_id: int | None
+        scheduled_acquisition_id = self.scheduled_acquisition_id
+
+        created_at = self.created_at.isoformat()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "occurrence_local_date": occurrence_local_date,
+                "kind": kind,
+                "scheduled_acquisition_id": scheduled_acquisition_id,
+                "created_at": created_at,
+            }
+        )
+
+        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"))
+
+        kind = RecurrenceExceptionKind(d.pop("kind"))
+
+        def _parse_scheduled_acquisition_id(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        scheduled_acquisition_id = _parse_scheduled_acquisition_id(
+            d.pop("scheduled_acquisition_id")
+        )
+
+        created_at = datetime.datetime.fromisoformat(d.pop("created_at"))
+
+        recurrence_exception_response = cls(
+            occurrence_local_date=occurrence_local_date,
+            kind=kind,
+            scheduled_acquisition_id=scheduled_acquisition_id,
+            created_at=created_at,
+        )
+
+        recurrence_exception_response.additional_properties = d
+        return recurrence_exception_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/recurrence_frequency.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class RecurrenceFrequency(str, Enum):
+    DAILY = "daily"
+    WEEKLY = "weekly"
+
+    def __str__(self) -> str:
+        return str(self.value)

docket/models/recurrence_preview_response.py

@@ -0,0 +1,101 @@
+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.occurrence_preview import OccurrencePreview
+    from ..models.skipped_occurrence import SkippedOccurrence
+
+
+T = TypeVar("T", bound="RecurrencePreviewResponse")
+
+
+@_attrs_define
+class RecurrencePreviewResponse:
+    """What creating the series would do. Nothing was written.
+
+    Attributes:
+        occurrences (list[OccurrencePreview]): Occurrences that would be created, in order.
+        skipped (list[SkippedOccurrence]): Occurrences that would be skipped, in order.
+    """
+
+    occurrences: list[OccurrencePreview]
+    skipped: list[SkippedOccurrence]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        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)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "occurrences": occurrences,
+                "skipped": skipped,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        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)
+
+        recurrence_preview_response = cls(
+            occurrences=occurrences,
+            skipped=skipped,
+        )
+
+        recurrence_preview_response.additional_properties = d
+        return recurrence_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