dart-tools 0.8.4__py3-none-any.whl → 0.8.8__py3-none-any.whl

dart/generated/models/paginated_concise_doc_list_meta_type_0.py

@@ -0,0 +1,109 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.paginated_concise_doc_list_meta_type_0_applied_default_filters import (
+        PaginatedConciseDocListMetaType0AppliedDefaultFilters,
+    )
+
+
+T = TypeVar("T", bound="PaginatedConciseDocListMetaType0")
+
+
+@_attrs_define
+class PaginatedConciseDocListMetaType0:
+    """
+    Attributes:
+        defaults_applied (Union[Unset, bool]): Whether default filters or ordering were applied to the response.
+        applied_default_filters (Union[Unset, PaginatedConciseDocListMetaType0AppliedDefaultFilters]): The default
+            filters that were applied automatically, if any.
+        applied_default_sorts (Union[Unset, list[str]]): The default ordering fields that were applied automatically, if
+            any.
+        instructions (Union[Unset, str]): Guidance on how to disable or override default filters and ordering.
+    """
+
+    defaults_applied: Union[Unset, bool] = UNSET
+    applied_default_filters: Union[Unset, "PaginatedConciseDocListMetaType0AppliedDefaultFilters"] = UNSET
+    applied_default_sorts: Union[Unset, list[str]] = UNSET
+    instructions: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        defaults_applied = self.defaults_applied
+
+        applied_default_filters: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.applied_default_filters, Unset):
+            applied_default_filters = self.applied_default_filters.to_dict()
+
+        applied_default_sorts: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.applied_default_sorts, Unset):
+            applied_default_sorts = self.applied_default_sorts
+
+        instructions = self.instructions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if defaults_applied is not UNSET:
+            field_dict["defaultsApplied"] = defaults_applied
+        if applied_default_filters is not UNSET:
+            field_dict["appliedDefaultFilters"] = applied_default_filters
+        if applied_default_sorts is not UNSET:
+            field_dict["appliedDefaultSorts"] = applied_default_sorts
+        if instructions is not UNSET:
+            field_dict["instructions"] = instructions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.paginated_concise_doc_list_meta_type_0_applied_default_filters import (
+            PaginatedConciseDocListMetaType0AppliedDefaultFilters,
+        )
+
+        d = dict(src_dict)
+        defaults_applied = d.pop("defaultsApplied", UNSET)
+
+        _applied_default_filters = d.pop("appliedDefaultFilters", UNSET)
+        applied_default_filters: Union[Unset, PaginatedConciseDocListMetaType0AppliedDefaultFilters]
+        if isinstance(_applied_default_filters, Unset):
+            applied_default_filters = UNSET
+        else:
+            applied_default_filters = PaginatedConciseDocListMetaType0AppliedDefaultFilters.from_dict(
+                _applied_default_filters
+            )
+
+        applied_default_sorts = cast(list[str], d.pop("appliedDefaultSorts", UNSET))
+
+        instructions = d.pop("instructions", UNSET)
+
+        paginated_concise_doc_list_meta_type_0 = cls(
+            defaults_applied=defaults_applied,
+            applied_default_filters=applied_default_filters,
+            applied_default_sorts=applied_default_sorts,
+            instructions=instructions,
+        )
+
+        paginated_concise_doc_list_meta_type_0.additional_properties = d
+        return paginated_concise_doc_list_meta_type_0
+
+    @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

dart/generated/models/paginated_concise_doc_list_meta_type_0_applied_default_filters.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PaginatedConciseDocListMetaType0AppliedDefaultFilters")
+
+
+@_attrs_define
+class PaginatedConciseDocListMetaType0AppliedDefaultFilters:
+    """The default filters that were applied automatically, if any."""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        paginated_concise_doc_list_meta_type_0_applied_default_filters = cls()
+
+        paginated_concise_doc_list_meta_type_0_applied_default_filters.additional_properties = d
+        return paginated_concise_doc_list_meta_type_0_applied_default_filters
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: 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

dart/generated/models/paginated_concise_task_list.py

@@ -8,6 +8,9 @@ from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
     from ..models.concise_task import ConciseTask
+    from ..models.paginated_concise_task_list_meta_type_0 import (
+        PaginatedConciseTaskListMetaType0,
+    )
 
 
 T = TypeVar("T", bound="PaginatedConciseTaskList")
@@ -21,15 +24,21 @@ class PaginatedConciseTaskList:
         results (list['ConciseTask']):
         next_ (Union[None, Unset, str]):  Example: http://api.example.org/accounts/?offset=400&limit=100.
         previous (Union[None, Unset, str]):  Example: http://api.example.org/accounts/?offset=200&limit=100.
+        meta (Union['PaginatedConciseTaskListMetaType0', None, Unset]):
     """
 
     count: int
     results: list["ConciseTask"]
     next_: Union[None, Unset, str] = UNSET
     previous: Union[None, Unset, str] = UNSET
+    meta: Union["PaginatedConciseTaskListMetaType0", None, Unset] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.paginated_concise_task_list_meta_type_0 import (
+            PaginatedConciseTaskListMetaType0,
+        )
+
         count = self.count
 
         results = []
@@ -49,6 +58,14 @@ class PaginatedConciseTaskList:
         else:
             previous = self.previous
 
+        meta: Union[None, Unset, dict[str, Any]]
+        if isinstance(self.meta, Unset):
+            meta = UNSET
+        elif isinstance(self.meta, PaginatedConciseTaskListMetaType0):
+            meta = self.meta.to_dict()
+        else:
+            meta = self.meta
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -61,12 +78,17 @@ class PaginatedConciseTaskList:
             field_dict["next"] = next_
         if previous is not UNSET:
             field_dict["previous"] = previous
+        if meta is not UNSET:
+            field_dict["meta"] = meta
 
         return field_dict
 
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.concise_task import ConciseTask
+        from ..models.paginated_concise_task_list_meta_type_0 import (
+            PaginatedConciseTaskListMetaType0,
+        )
 
         d = dict(src_dict)
         count = d.pop("count")
@@ -96,11 +118,31 @@ class PaginatedConciseTaskList:
 
         previous = _parse_previous(d.pop("previous", UNSET))
 
+        def _parse_meta(
+            data: object,
+        ) -> Union["PaginatedConciseTaskListMetaType0", None, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                meta_type_0 = PaginatedConciseTaskListMetaType0.from_dict(data)
+
+                return meta_type_0
+            except:  # noqa: E722
+                pass
+            return cast(Union["PaginatedConciseTaskListMetaType0", None, Unset], data)
+
+        meta = _parse_meta(d.pop("meta", UNSET))
+
         paginated_concise_task_list = cls(
             count=count,
             results=results,
             next_=next_,
             previous=previous,
+            meta=meta,
         )
 
         paginated_concise_task_list.additional_properties = d

dart/generated/models/paginated_concise_task_list_meta_type_0.py

@@ -0,0 +1,109 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.paginated_concise_task_list_meta_type_0_applied_default_filters import (
+        PaginatedConciseTaskListMetaType0AppliedDefaultFilters,
+    )
+
+
+T = TypeVar("T", bound="PaginatedConciseTaskListMetaType0")
+
+
+@_attrs_define
+class PaginatedConciseTaskListMetaType0:
+    """
+    Attributes:
+        defaults_applied (Union[Unset, bool]): Whether default filters or ordering were applied to the response.
+        applied_default_filters (Union[Unset, PaginatedConciseTaskListMetaType0AppliedDefaultFilters]): The default
+            filters that were applied automatically, if any.
+        applied_default_sorts (Union[Unset, list[str]]): The default ordering fields that were applied automatically, if
+            any.
+        instructions (Union[Unset, str]): Guidance on how to disable or override default filters and ordering.
+    """
+
+    defaults_applied: Union[Unset, bool] = UNSET
+    applied_default_filters: Union[Unset, "PaginatedConciseTaskListMetaType0AppliedDefaultFilters"] = UNSET
+    applied_default_sorts: Union[Unset, list[str]] = UNSET
+    instructions: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        defaults_applied = self.defaults_applied
+
+        applied_default_filters: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.applied_default_filters, Unset):
+            applied_default_filters = self.applied_default_filters.to_dict()
+
+        applied_default_sorts: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.applied_default_sorts, Unset):
+            applied_default_sorts = self.applied_default_sorts
+
+        instructions = self.instructions
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if defaults_applied is not UNSET:
+            field_dict["defaultsApplied"] = defaults_applied
+        if applied_default_filters is not UNSET:
+            field_dict["appliedDefaultFilters"] = applied_default_filters
+        if applied_default_sorts is not UNSET:
+            field_dict["appliedDefaultSorts"] = applied_default_sorts
+        if instructions is not UNSET:
+            field_dict["instructions"] = instructions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.paginated_concise_task_list_meta_type_0_applied_default_filters import (
+            PaginatedConciseTaskListMetaType0AppliedDefaultFilters,
+        )
+
+        d = dict(src_dict)
+        defaults_applied = d.pop("defaultsApplied", UNSET)
+
+        _applied_default_filters = d.pop("appliedDefaultFilters", UNSET)
+        applied_default_filters: Union[Unset, PaginatedConciseTaskListMetaType0AppliedDefaultFilters]
+        if isinstance(_applied_default_filters, Unset):
+            applied_default_filters = UNSET
+        else:
+            applied_default_filters = PaginatedConciseTaskListMetaType0AppliedDefaultFilters.from_dict(
+                _applied_default_filters
+            )
+
+        applied_default_sorts = cast(list[str], d.pop("appliedDefaultSorts", UNSET))
+
+        instructions = d.pop("instructions", UNSET)
+
+        paginated_concise_task_list_meta_type_0 = cls(
+            defaults_applied=defaults_applied,
+            applied_default_filters=applied_default_filters,
+            applied_default_sorts=applied_default_sorts,
+            instructions=instructions,
+        )
+
+        paginated_concise_task_list_meta_type_0.additional_properties = d
+        return paginated_concise_task_list_meta_type_0
+
+    @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

dart/generated/models/paginated_concise_task_list_meta_type_0_applied_default_filters.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PaginatedConciseTaskListMetaType0AppliedDefaultFilters")
+
+
+@_attrs_define
+class PaginatedConciseTaskListMetaType0AppliedDefaultFilters:
+    """The default filters that were applied automatically, if any."""
+
+    additional_properties: dict[str, str] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        paginated_concise_task_list_meta_type_0_applied_default_filters = cls()
+
+        paginated_concise_task_list_meta_type_0_applied_default_filters.additional_properties = d
+        return paginated_concise_task_list_meta_type_0_applied_default_filters
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: 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

dart/generated/models/task.py

@@ -1,8 +1,10 @@
+import datetime
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
+from dateutil.parser import isoparse
 
 from ..models.priority import Priority
 from ..types import UNSET, Unset
@@ -32,6 +34,8 @@ class Task:
         description (str): A longer description of the task, which can include markdown formatting.
         attachments (list['Attachment']): The attachments, which is a list of attachments that are associated with the
             task.
+        created_at (datetime.datetime): The date and time when the task was created in ISO format.
+        updated_at (datetime.datetime): The date and time when the task was last updated in ISO format.
         assignees (Union[None, Unset, list[str]]): The names or emails of the users that the task is assigned to. Either
             this or assignee must be included, depending on whether the workspaces allows multiple assignees or not.
         assignee (Union[None, Unset, str]): The name or email of the user that the task is assigned to. Either this or
@@ -52,6 +56,8 @@ class Task:
         custom_properties (Union['CustomProperties', None, Unset]): The custom properties, which is a dict of custom
             properties that are associated with the task.
         task_relationships (Union['TaskRelationshipsType0', None, Unset]): The relationships associated with the task.
+        created_by (Union[None, Unset, str]): The name or email (moniker) of the user that created the task.
+        updated_by (Union[None, Unset, str]): The name or email (moniker) of the user that last updated the task.
     """
 
     id: str
@@ -63,6 +69,8 @@ class Task:
     status: str
     description: str
     attachments: list["Attachment"]
+    created_at: datetime.datetime
+    updated_at: datetime.datetime
     assignees: Union[None, Unset, list[str]] = UNSET
     assignee: Union[None, Unset, str] = UNSET
     tags: Union[Unset, list[str]] = UNSET
@@ -73,6 +81,8 @@ class Task:
     time_tracking: Union[Unset, str] = UNSET
     custom_properties: Union["CustomProperties", None, Unset] = UNSET
     task_relationships: Union["TaskRelationshipsType0", None, Unset] = UNSET
+    created_by: Union[None, Unset, str] = UNSET
+    updated_by: Union[None, Unset, str] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
     def to_dict(self) -> dict[str, Any]:
@@ -101,6 +111,10 @@ class Task:
             attachments_item = attachments_item_data.to_dict()
             attachments.append(attachments_item)
 
+        created_at = self.created_at.isoformat()
+
+        updated_at = self.updated_at.isoformat()
+
         assignees: Union[None, Unset, list[str]]
         if isinstance(self.assignees, Unset):
             assignees = UNSET
@@ -164,6 +178,18 @@ class Task:
         else:
             task_relationships = self.task_relationships
 
+        created_by: Union[None, Unset, str]
+        if isinstance(self.created_by, Unset):
+            created_by = UNSET
+        else:
+            created_by = self.created_by
+
+        updated_by: Union[None, Unset, str]
+        if isinstance(self.updated_by, Unset):
+            updated_by = UNSET
+        else:
+            updated_by = self.updated_by
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
@@ -177,6 +203,8 @@ class Task:
                 "status": status,
                 "description": description,
                 "attachments": attachments,
+                "createdAt": created_at,
+                "updatedAt": updated_at,
             }
         )
         if assignees is not UNSET:
@@ -199,6 +227,10 @@ class Task:
             field_dict["customProperties"] = custom_properties
         if task_relationships is not UNSET:
             field_dict["taskRelationships"] = task_relationships
+        if created_by is not UNSET:
+            field_dict["createdBy"] = created_by
+        if updated_by is not UNSET:
+            field_dict["updatedBy"] = updated_by
 
         return field_dict
 
@@ -237,6 +269,10 @@ class Task:
 
             attachments.append(attachments_item)
 
+        created_at = isoparse(d.pop("createdAt"))
+
+        updated_at = isoparse(d.pop("updatedAt"))
+
         def _parse_assignees(data: object) -> Union[None, Unset, list[str]]:
             if data is None:
                 return data
@@ -349,6 +385,24 @@ class Task:
 
         task_relationships = _parse_task_relationships(d.pop("taskRelationships", UNSET))
 
+        def _parse_created_by(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        created_by = _parse_created_by(d.pop("createdBy", UNSET))
+
+        def _parse_updated_by(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        updated_by = _parse_updated_by(d.pop("updatedBy", UNSET))
+
         task = cls(
             id=id,
             html_url=html_url,
@@ -359,6 +413,8 @@ class Task:
             status=status,
             description=description,
             attachments=attachments,
+            created_at=created_at,
+            updated_at=updated_at,
             assignees=assignees,
             assignee=assignee,
             tags=tags,
@@ -369,6 +425,8 @@ class Task:
             time_tracking=time_tracking,
             custom_properties=custom_properties,
             task_relationships=task_relationships,
+            created_by=created_by,
+            updated_by=updated_by,
         )
 
         task.additional_properties = d

dart/generated/models/task_move.py

@@ -0,0 +1,94 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TaskMove")
+
+
+@_attrs_define
+class TaskMove:
+    """
+    Attributes:
+        before_task_id (Union[None, Unset, str]): Move the task immediately before this task. For example: if tasks are
+            [A, B, C], then beforeTaskId=B produces [A, moved_task, B, C]. Use null to move to the beginning (first
+            position).
+        after_task_id (Union[None, Unset, str]): Move the task immediately after this task. For example: if tasks are
+            [A, B, C], then afterTaskId=B produces [A, B, moved_task, C]. Use null to move to the end (last position).
+    """
+
+    before_task_id: Union[None, Unset, str] = UNSET
+    after_task_id: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        before_task_id: Union[None, Unset, str]
+        if isinstance(self.before_task_id, Unset):
+            before_task_id = UNSET
+        else:
+            before_task_id = self.before_task_id
+
+        after_task_id: Union[None, Unset, str]
+        if isinstance(self.after_task_id, Unset):
+            after_task_id = UNSET
+        else:
+            after_task_id = self.after_task_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if before_task_id is not UNSET:
+            field_dict["beforeTaskId"] = before_task_id
+        if after_task_id is not UNSET:
+            field_dict["afterTaskId"] = after_task_id
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+
+        def _parse_before_task_id(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        before_task_id = _parse_before_task_id(d.pop("beforeTaskId", UNSET))
+
+        def _parse_after_task_id(data: object) -> Union[None, Unset, str]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, str], data)
+
+        after_task_id = _parse_after_task_id(d.pop("afterTaskId", UNSET))
+
+        task_move = cls(
+            before_task_id=before_task_id,
+            after_task_id=after_task_id,
+        )
+
+        task_move.additional_properties = d
+        return task_move
+
+    @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