docket-client 0.3.2__py3-none-any.whl

docket/models/recurrence_rule.py

@@ -0,0 +1,207 @@
+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_frequency import RecurrenceFrequency
+from ..models.weekday import Weekday
+from ..types import UNSET, Unset
+from typing import cast
+import datetime
+
+
+T = TypeVar("T", bound="RecurrenceRule")
+
+
+@_attrs_define
+class 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).
+
+        Attributes:
+            frequency (RecurrenceFrequency):
+            local_start_time (str): Wall-clock time of day, e.g. 09:00:00.
+            duration_minutes (int): Planned length of each occurrence in elapsed minutes, at least 1.
+            time_zone (str): IANA zone id such as `America/Los_Angeles`. Required; never inferred from an offset.
+            start_date (datetime.date): Calendar date, e.g. 2026-10-15.
+            interval (int | Unset): Every n days or weeks; at least 1. Default: 1.
+            weekdays (list[Weekday] | None | Unset): Weekly only, at least one: the days of the week (in the recurrence
+                zone). Omit for daily.
+            count (int | None | Unset): Number of occurrences, 1-366; skipped daylight-saving occurrences count toward it.
+                The last one must fall within six months of `start_date`.
+            until (datetime.date | None | Unset): Last local date, inclusive; at most six calendar months after `start_date`
+                (a series is never open-ended).
+    """
+
+    frequency: RecurrenceFrequency
+    local_start_time: str
+    duration_minutes: int
+    time_zone: str
+    start_date: datetime.date
+    interval: int | Unset = 1
+    weekdays: list[Weekday] | None | Unset = UNSET
+    count: int | None | Unset = UNSET
+    until: datetime.date | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        frequency = self.frequency.value
+
+        local_start_time = self.local_start_time
+
+        duration_minutes = self.duration_minutes
+
+        time_zone = self.time_zone
+
+        start_date = self.start_date.isoformat()
+
+        interval = self.interval
+
+        weekdays: list[str] | None | Unset
+        if isinstance(self.weekdays, Unset):
+            weekdays = UNSET
+        elif isinstance(self.weekdays, list):
+            weekdays = []
+            for weekdays_type_1_item_data in self.weekdays:
+                weekdays_type_1_item = weekdays_type_1_item_data.value
+                weekdays.append(weekdays_type_1_item)
+
+        else:
+            weekdays = self.weekdays
+
+        count: int | None | Unset
+        if isinstance(self.count, Unset):
+            count = UNSET
+        else:
+            count = self.count
+
+        until: None | str | Unset
+        if isinstance(self.until, Unset):
+            until = UNSET
+        elif isinstance(self.until, datetime.date):
+            until = self.until.isoformat()
+        else:
+            until = self.until
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "frequency": frequency,
+                "local_start_time": local_start_time,
+                "duration_minutes": duration_minutes,
+                "time_zone": time_zone,
+                "start_date": start_date,
+            }
+        )
+        if interval is not UNSET:
+            field_dict["interval"] = interval
+        if weekdays is not UNSET:
+            field_dict["weekdays"] = weekdays
+        if count is not UNSET:
+            field_dict["count"] = count
+        if until is not UNSET:
+            field_dict["until"] = until
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        frequency = RecurrenceFrequency(d.pop("frequency"))
+
+        local_start_time = d.pop("local_start_time")
+
+        duration_minutes = d.pop("duration_minutes")
+
+        time_zone = d.pop("time_zone")
+
+        start_date = datetime.date.fromisoformat(d.pop("start_date"))
+
+        interval = d.pop("interval", UNSET)
+
+        def _parse_weekdays(data: object) -> list[Weekday] | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                weekdays_type_1 = []
+                _weekdays_type_1 = data
+                for weekdays_type_1_item_data in _weekdays_type_1:
+                    weekdays_type_1_item = Weekday(weekdays_type_1_item_data)
+
+                    weekdays_type_1.append(weekdays_type_1_item)
+
+                return weekdays_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(list[Weekday] | None | Unset, data)
+
+        weekdays = _parse_weekdays(d.pop("weekdays", UNSET))
+
+        def _parse_count(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        count = _parse_count(d.pop("count", UNSET))
+
+        def _parse_until(data: object) -> datetime.date | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                until_type_1 = datetime.date.fromisoformat(data)
+
+                return until_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(datetime.date | None | Unset, data)
+
+        until = _parse_until(d.pop("until", UNSET))
+
+        recurrence_rule = cls(
+            frequency=frequency,
+            local_start_time=local_start_time,
+            duration_minutes=duration_minutes,
+            time_zone=time_zone,
+            start_date=start_date,
+            interval=interval,
+            weekdays=weekdays,
+            count=count,
+            until=until,
+        )
+
+        recurrence_rule.additional_properties = d
+        return recurrence_rule
+
+    @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/recurring_acquisition_created_response.py

@@ -0,0 +1,123 @@
+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_warnings import OccurrenceWarnings
+    from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+    from ..models.skipped_occurrence import SkippedOccurrence
+
+
+T = TypeVar("T", bound="RecurringAcquisitionCreatedResponse")
+
+
+@_attrs_define
+class RecurringAcquisitionCreatedResponse:
+    """A created series.
+
+    Attributes:
+        definition (RecurringAcquisitionResponse): A recurring definition: scheduling intent, from which occurrences
+            were materialized.
+        occurrence_ids (list[int]): Ids of the created scheduled acquisitions, in occurrence order.
+        skipped (list[SkippedOccurrence]): Occurrences skipped because their local time does not exist or is ambiguous;
+            add them by hand if wanted.
+        warnings (list[OccurrenceWarnings]): Overlap warnings per occurrence; only occurrences that have any are listed.
+            Warnings never reject the write.
+    """
+
+    definition: RecurringAcquisitionResponse
+    occurrence_ids: list[int]
+    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.occurrence_warnings import OccurrenceWarnings
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+        from ..models.skipped_occurrence import SkippedOccurrence
+
+        definition = self.definition.to_dict()
+
+        occurrence_ids = self.occurrence_ids
+
+        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,
+                "occurrence_ids": occurrence_ids,
+                "skipped": skipped,
+                "warnings": warnings,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        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"))
+
+        occurrence_ids = cast(list[int], d.pop("occurrence_ids"))
+
+        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)
+
+        recurring_acquisition_created_response = cls(
+            definition=definition,
+            occurrence_ids=occurrence_ids,
+            skipped=skipped,
+            warnings=warnings,
+        )
+
+        recurring_acquisition_created_response.additional_properties = d
+        return recurring_acquisition_created_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/recurring_acquisition_detail_response.py

@@ -0,0 +1,105 @@
+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_summary import OccurrenceSummary
+    from ..models.recurrence_exception_response import RecurrenceExceptionResponse
+    from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+
+T = TypeVar("T", bound="RecurringAcquisitionDetailResponse")
+
+
+@_attrs_define
+class RecurringAcquisitionDetailResponse:
+    """A definition with a summary of what it produced.
+
+    Attributes:
+        definition (RecurringAcquisitionResponse): A recurring definition: scheduling intent, from which occurrences
+            were materialized.
+        occurrences (OccurrenceSummary): Summary of a series' occurrences (archived ones included).
+        exceptions (list[RecurrenceExceptionResponse]):
+    """
+
+    definition: RecurringAcquisitionResponse
+    occurrences: OccurrenceSummary
+    exceptions: list[RecurrenceExceptionResponse]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.occurrence_summary import OccurrenceSummary
+        from ..models.recurrence_exception_response import RecurrenceExceptionResponse
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+        definition = self.definition.to_dict()
+
+        occurrences = self.occurrences.to_dict()
+
+        exceptions = []
+        for exceptions_item_data in self.exceptions:
+            exceptions_item = exceptions_item_data.to_dict()
+            exceptions.append(exceptions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "definition": definition,
+                "occurrences": occurrences,
+                "exceptions": exceptions,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.occurrence_summary import OccurrenceSummary
+        from ..models.recurrence_exception_response import RecurrenceExceptionResponse
+        from ..models.recurring_acquisition_response import RecurringAcquisitionResponse
+
+        d = dict(src_dict)
+        definition = RecurringAcquisitionResponse.from_dict(d.pop("definition"))
+
+        occurrences = OccurrenceSummary.from_dict(d.pop("occurrences"))
+
+        exceptions = []
+        _exceptions = d.pop("exceptions")
+        for exceptions_item_data in _exceptions:
+            exceptions_item = RecurrenceExceptionResponse.from_dict(exceptions_item_data)
+
+            exceptions.append(exceptions_item)
+
+        recurring_acquisition_detail_response = cls(
+            definition=definition,
+            occurrences=occurrences,
+            exceptions=exceptions,
+        )
+
+        recurring_acquisition_detail_response.additional_properties = d
+        return recurring_acquisition_detail_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