dart-tools 0.6.15__py3-none-any.whl → 0.7.0__py3-none-any.whl

dart/generated/models/user.py

@@ -1,18 +1,9 @@
-from typing import TYPE_CHECKING, Any, Dict, List, Type, TypeVar, Union, cast
+from collections.abc import Mapping
+from typing import Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..models.task_detail_mode import TaskDetailMode
-from ..models.theme import Theme
-from ..models.user_role import UserRole
-from ..models.user_status import UserStatus
-from ..types import UNSET, Unset
-
-if TYPE_CHECKING:
-    from ..models.google_data import GoogleData
-
-
 T = TypeVar("T", bound="User")
 
 
@@ -20,216 +11,47 @@ T = TypeVar("T", bound="User")
 class User:
     """
     Attributes:
-        duid (str):
-        status (UserStatus): * `PendingSubscriptionUpgrade` - PENDING_SUBSCRIPTION_UPGRADE
-            * `Invited` - INVITED
-            * `PendingEmailVerification` - PENDING_EMAIL_VERIFICATION
-            * `Active` - ACTIVE
-            * `Deactivated` - DEACTIVATED
-        role (UserRole): * `Admin` - ADMIN
-            * `Member` - MEMBER
-            * `Guest` - GUEST
-            * `Technical admin` - TECHNICAL_ADMIN
-            * `Financial admin` - FINANCIAL_ADMIN
-        email (str):
         name (str):
-        abrev (str):
-        theme (Theme): * `System Default` - SYSTEM_DEFAULT
-            * `Light` - LIGHT
-            * `Dark` - DARK
-        color_hex (str):
-        task_detail_mode (TaskDetailMode): * `Rightbar` - RIGHTBAR
-            * `Fullscreen` - FULLSCREEN
-            * `Overlay` - OVERLAY
-        sections (Any):
-        layout (Any):
-        auth_token (Union[None, str]):
-        image_url (Union[None, str]):
-        is_admin (bool):
-        google_data (Union['GoogleData', None]):
-        updated_by_client_duid (Union[None, Unset, str]):
+        email (str):
     """
 
-    duid: str
-    status: UserStatus
-    role: UserRole
-    email: str
     name: str
-    abrev: str
-    theme: Theme
-    color_hex: str
-    task_detail_mode: TaskDetailMode
-    sections: Any
-    layout: Any
-    auth_token: Union[None, str]
-    image_url: Union[None, str]
-    is_admin: bool
-    google_data: Union["GoogleData", None]
-    updated_by_client_duid: Union[None, Unset, str] = UNSET
-    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        from ..models.google_data import GoogleData
-
-        duid = self.duid
-
-        status = self.status.value
-
-        role = self.role.value
-
-        email = self.email
+    email: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
+    def to_dict(self) -> dict[str, Any]:
         name = self.name
 
-        abrev = self.abrev
-
-        theme = self.theme.value
-
-        color_hex = self.color_hex
-
-        task_detail_mode = self.task_detail_mode.value
-
-        sections = self.sections
-
-        layout = self.layout
-
-        auth_token: Union[None, str]
-        auth_token = self.auth_token
-
-        image_url: Union[None, str]
-        image_url = self.image_url
-
-        is_admin = self.is_admin
-
-        google_data: Union[Dict[str, Any], None]
-        if isinstance(self.google_data, GoogleData):
-            google_data = self.google_data.to_dict()
-        else:
-            google_data = self.google_data
-
-        updated_by_client_duid: Union[None, Unset, str]
-        if isinstance(self.updated_by_client_duid, Unset):
-            updated_by_client_duid = UNSET
-        else:
-            updated_by_client_duid = self.updated_by_client_duid
+        email = self.email
 
-        field_dict: Dict[str, Any] = {}
+        field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
-                "duid": duid,
-                "status": status,
-                "role": role,
-                "email": email,
                 "name": name,
-                "abrev": abrev,
-                "theme": theme,
-                "colorHex": color_hex,
-                "taskDetailMode": task_detail_mode,
-                "sections": sections,
-                "layout": layout,
-                "authToken": auth_token,
-                "imageUrl": image_url,
-                "isAdmin": is_admin,
-                "googleData": google_data,
+                "email": email,
             }
         )
-        if updated_by_client_duid is not UNSET:
-            field_dict["updatedByClientDuid"] = updated_by_client_duid
 
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
-        from ..models.google_data import GoogleData
-
-        d = src_dict.copy()
-        duid = d.pop("duid")
-
-        status = UserStatus(d.pop("status"))
-
-        role = UserRole(d.pop("role"))
-
-        email = d.pop("email")
-
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
         name = d.pop("name")
 
-        abrev = d.pop("abrev")
-
-        theme = Theme(d.pop("theme"))
-
-        color_hex = d.pop("colorHex")
-
-        task_detail_mode = TaskDetailMode(d.pop("taskDetailMode"))
-
-        sections = d.pop("sections")
-
-        layout = d.pop("layout")
-
-        def _parse_auth_token(data: object) -> Union[None, str]:
-            if data is None:
-                return data
-            return cast(Union[None, str], data)
-
-        auth_token = _parse_auth_token(d.pop("authToken"))
-
-        def _parse_image_url(data: object) -> Union[None, str]:
-            if data is None:
-                return data
-            return cast(Union[None, str], data)
-
-        image_url = _parse_image_url(d.pop("imageUrl"))
-
-        is_admin = d.pop("isAdmin")
-
-        def _parse_google_data(data: object) -> Union["GoogleData", None]:
-            if data is None:
-                return data
-            try:
-                if not isinstance(data, dict):
-                    raise TypeError()
-                google_data_type_0 = GoogleData.from_dict(data)
-
-                return google_data_type_0
-            except:  # noqa: E722
-                pass
-            return cast(Union["GoogleData", None], data)
-
-        google_data = _parse_google_data(d.pop("googleData"))
-
-        def _parse_updated_by_client_duid(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_client_duid = _parse_updated_by_client_duid(d.pop("updatedByClientDuid", UNSET))
+        email = d.pop("email")
 
         user = cls(
-            duid=duid,
-            status=status,
-            role=role,
-            email=email,
             name=name,
-            abrev=abrev,
-            theme=theme,
-            color_hex=color_hex,
-            task_detail_mode=task_detail_mode,
-            sections=sections,
-            layout=layout,
-            auth_token=auth_token,
-            image_url=image_url,
-            is_admin=is_admin,
-            google_data=google_data,
-            updated_by_client_duid=updated_by_client_duid,
+            email=email,
         )
 
         user.additional_properties = d
         return user
 
     @property
-    def additional_keys(self) -> List[str]:
+    def additional_keys(self) -> list[str]:
         return list(self.additional_properties.keys())
 
     def __getitem__(self, key: str) -> Any:

dart/generated/models/user_space_configuration.py

@@ -0,0 +1,147 @@
+import datetime
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+from dateutil.parser import isoparse
+
+if TYPE_CHECKING:
+    from ..models.user import User
+
+
+T = TypeVar("T", bound="UserSpaceConfiguration")
+
+
+@_attrs_define
+class UserSpaceConfiguration:
+    """
+    Attributes:
+        today (datetime.date):
+        user (User):
+        dartboards (list[str]):
+        folders (list[str]):
+        types (list[str]):
+        statuses (list[str]):
+        assignees (list['User']):
+        tags (list[str]):
+        priorities (list[str]):
+        sizes (list[int]):
+    """
+
+    today: datetime.date
+    user: "User"
+    dartboards: list[str]
+    folders: list[str]
+    types: list[str]
+    statuses: list[str]
+    assignees: list["User"]
+    tags: list[str]
+    priorities: list[str]
+    sizes: list[int]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        today = self.today.isoformat()
+
+        user = self.user.to_dict()
+
+        dartboards = self.dartboards
+
+        folders = self.folders
+
+        types = self.types
+
+        statuses = self.statuses
+
+        assignees = []
+        for assignees_item_data in self.assignees:
+            assignees_item = assignees_item_data.to_dict()
+            assignees.append(assignees_item)
+
+        tags = self.tags
+
+        priorities = self.priorities
+
+        sizes = self.sizes
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "today": today,
+                "user": user,
+                "dartboards": dartboards,
+                "folders": folders,
+                "types": types,
+                "statuses": statuses,
+                "assignees": assignees,
+                "tags": tags,
+                "priorities": priorities,
+                "sizes": sizes,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.user import User
+
+        d = dict(src_dict)
+        today = isoparse(d.pop("today")).date()
+
+        user = User.from_dict(d.pop("user"))
+
+        dartboards = cast(list[str], d.pop("dartboards"))
+
+        folders = cast(list[str], d.pop("folders"))
+
+        types = cast(list[str], d.pop("types"))
+
+        statuses = cast(list[str], d.pop("statuses"))
+
+        assignees = []
+        _assignees = d.pop("assignees")
+        for assignees_item_data in _assignees:
+            assignees_item = User.from_dict(assignees_item_data)
+
+            assignees.append(assignees_item)
+
+        tags = cast(list[str], d.pop("tags"))
+
+        priorities = cast(list[str], d.pop("priorities"))
+
+        sizes = cast(list[int], d.pop("sizes"))
+
+        user_space_configuration = cls(
+            today=today,
+            user=user,
+            dartboards=dartboards,
+            folders=folders,
+            types=types,
+            statuses=statuses,
+            assignees=assignees,
+            tags=tags,
+            priorities=priorities,
+            sizes=sizes,
+        )
+
+        user_space_configuration.additional_properties = d
+        return user_space_configuration
+
+    @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/view.py

@@ -1,11 +1,12 @@
-from typing import Any, Dict, List, Type, TypeVar, Union, cast
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
-from ..models.icon_kind import IconKind
-from ..models.view_kind import ViewKind
-from ..types import UNSET, Unset
+if TYPE_CHECKING:
+    from ..models.task import Task
+
 
 T = TypeVar("T", bound="View")
 
@@ -14,192 +15,81 @@ T = TypeVar("T", bound="View")
 class View:
     """
     Attributes:
-        duid (str):
-        kind (ViewKind): * `Custom` - CUSTOM
-            * `Search` - SEARCH
-            * `Trash` - TRASH
-            * `My tasks` - MY_TASKS
-        accessible_by_team (bool):
-        accessible_by_user_duids (List[str]):
-        public (bool):
-        order (str):
-        title (str):
-        description (str):
-        icon_kind (IconKind): * `None` - NONE
-            * `Icon` - ICON
-            * `Emoji` - EMOJI
-        icon_name_or_emoji (str):
-        color_hex (str):
-        layout_duid (str):
-        favorited_by_user_duids (List[str]):
-        always_shown_property_duids (List[str]):
-        always_hidden_property_duids (List[str]):
-        property_order_duids (List[str]):
-        property_width_map (Any):
-        updated_by_client_duid (Union[None, Unset, str]):
+        id (str): The universal, unique ID of the view.
+        html_url (str): The URL that can be used to open the view in the Dart web UI.
+        title (str): The title, which is a short description of the view.
+        description (str): The description, which is a longer description of the view.
+        tasks (list['Task']): The list of all of the tasks in the view.
     """
 
-    duid: str
-    kind: ViewKind
-    accessible_by_team: bool
-    accessible_by_user_duids: List[str]
-    public: bool
-    order: str
+    id: str
+    html_url: str
     title: str
     description: str
-    icon_kind: IconKind
-    icon_name_or_emoji: str
-    color_hex: str
-    layout_duid: str
-    favorited_by_user_duids: List[str]
-    always_shown_property_duids: List[str]
-    always_hidden_property_duids: List[str]
-    property_order_duids: List[str]
-    property_width_map: Any
-    updated_by_client_duid: Union[None, Unset, str] = UNSET
-    additional_properties: Dict[str, Any] = _attrs_field(init=False, factory=dict)
-
-    def to_dict(self) -> Dict[str, Any]:
-        duid = self.duid
-
-        kind = self.kind.value
-
-        accessible_by_team = self.accessible_by_team
+    tasks: list["Task"]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
-        accessible_by_user_duids = self.accessible_by_user_duids
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
 
-        public = self.public
-
-        order = self.order
+        html_url = self.html_url
 
         title = self.title
 
         description = self.description
 
-        icon_kind = self.icon_kind.value
-
-        icon_name_or_emoji = self.icon_name_or_emoji
-
-        color_hex = self.color_hex
-
-        layout_duid = self.layout_duid
-
-        favorited_by_user_duids = self.favorited_by_user_duids
-
-        always_shown_property_duids = self.always_shown_property_duids
-
-        always_hidden_property_duids = self.always_hidden_property_duids
-
-        property_order_duids = self.property_order_duids
-
-        property_width_map = self.property_width_map
+        tasks = []
+        for tasks_item_data in self.tasks:
+            tasks_item = tasks_item_data.to_dict()
+            tasks.append(tasks_item)
 
-        updated_by_client_duid: Union[None, Unset, str]
-        if isinstance(self.updated_by_client_duid, Unset):
-            updated_by_client_duid = UNSET
-        else:
-            updated_by_client_duid = self.updated_by_client_duid
-
-        field_dict: Dict[str, Any] = {}
+        field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
         field_dict.update(
             {
-                "duid": duid,
-                "kind": kind,
-                "accessibleByTeam": accessible_by_team,
-                "accessibleByUserDuids": accessible_by_user_duids,
-                "public": public,
-                "order": order,
+                "id": id,
+                "htmlUrl": html_url,
                 "title": title,
                 "description": description,
-                "iconKind": icon_kind,
-                "iconNameOrEmoji": icon_name_or_emoji,
-                "colorHex": color_hex,
-                "layoutDuid": layout_duid,
-                "favoritedByUserDuids": favorited_by_user_duids,
-                "alwaysShownPropertyDuids": always_shown_property_duids,
-                "alwaysHiddenPropertyDuids": always_hidden_property_duids,
-                "propertyOrderDuids": property_order_duids,
-                "propertyWidthMap": property_width_map,
+                "tasks": tasks,
             }
         )
-        if updated_by_client_duid is not UNSET:
-            field_dict["updatedByClientDuid"] = updated_by_client_duid
 
         return field_dict
 
     @classmethod
-    def from_dict(cls: Type[T], src_dict: Dict[str, Any]) -> T:
-        d = src_dict.copy()
-        duid = d.pop("duid")
-
-        kind = ViewKind(d.pop("kind"))
-
-        accessible_by_team = d.pop("accessibleByTeam")
-
-        accessible_by_user_duids = cast(List[str], d.pop("accessibleByUserDuids"))
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.task import Task
 
-        public = d.pop("public")
+        d = dict(src_dict)
+        id = d.pop("id")
 
-        order = d.pop("order")
+        html_url = d.pop("htmlUrl")
 
         title = d.pop("title")
 
         description = d.pop("description")
 
-        icon_kind = IconKind(d.pop("iconKind"))
-
-        icon_name_or_emoji = d.pop("iconNameOrEmoji")
-
-        color_hex = d.pop("colorHex")
-
-        layout_duid = d.pop("layoutDuid")
-
-        favorited_by_user_duids = cast(List[str], d.pop("favoritedByUserDuids"))
-
-        always_shown_property_duids = cast(List[str], d.pop("alwaysShownPropertyDuids"))
-
-        always_hidden_property_duids = cast(List[str], d.pop("alwaysHiddenPropertyDuids"))
-
-        property_order_duids = cast(List[str], d.pop("propertyOrderDuids"))
-
-        property_width_map = d.pop("propertyWidthMap")
-
-        def _parse_updated_by_client_duid(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)
+        tasks = []
+        _tasks = d.pop("tasks")
+        for tasks_item_data in _tasks:
+            tasks_item = Task.from_dict(tasks_item_data)
 
-        updated_by_client_duid = _parse_updated_by_client_duid(d.pop("updatedByClientDuid", UNSET))
+            tasks.append(tasks_item)
 
         view = cls(
-            duid=duid,
-            kind=kind,
-            accessible_by_team=accessible_by_team,
-            accessible_by_user_duids=accessible_by_user_duids,
-            public=public,
-            order=order,
+            id=id,
+            html_url=html_url,
             title=title,
             description=description,
-            icon_kind=icon_kind,
-            icon_name_or_emoji=icon_name_or_emoji,
-            color_hex=color_hex,
-            layout_duid=layout_duid,
-            favorited_by_user_duids=favorited_by_user_duids,
-            always_shown_property_duids=always_shown_property_duids,
-            always_hidden_property_duids=always_hidden_property_duids,
-            property_order_duids=property_order_duids,
-            property_width_map=property_width_map,
-            updated_by_client_duid=updated_by_client_duid,
+            tasks=tasks,
         )
 
         view.additional_properties = d
         return view
 
     @property
-    def additional_keys(self) -> List[str]:
+    def additional_keys(self) -> list[str]:
         return list(self.additional_properties.keys())
 
     def __getitem__(self, key: str) -> Any:

dart/generated/models/wrapped_comment.py

@@ -0,0 +1,65 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.comment import Comment
+
+
+T = TypeVar("T", bound="WrappedComment")
+
+
+@_attrs_define
+class WrappedComment:
+    """
+    Attributes:
+        item (Comment):
+    """
+
+    item: "Comment"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        item = self.item.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "item": item,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.comment import Comment
+
+        d = dict(src_dict)
+        item = Comment.from_dict(d.pop("item"))
+
+        wrapped_comment = cls(
+            item=item,
+        )
+
+        wrapped_comment.additional_properties = d
+        return wrapped_comment
+
+    @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