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

dart/generated/models/wrapped_comment_create.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_create import CommentCreate
+
+
+T = TypeVar("T", bound="WrappedCommentCreate")
+
+
+@_attrs_define
+class WrappedCommentCreate:
+    """
+    Attributes:
+        item (CommentCreate):
+    """
+
+    item: "CommentCreate"
+    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_create import CommentCreate
+
+        d = dict(src_dict)
+        item = CommentCreate.from_dict(d.pop("item"))
+
+        wrapped_comment_create = cls(
+            item=item,
+        )
+
+        wrapped_comment_create.additional_properties = d
+        return wrapped_comment_create
+
+    @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/wrapped_dartboard.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.dartboard import Dartboard
+
+
+T = TypeVar("T", bound="WrappedDartboard")
+
+
+@_attrs_define
+class WrappedDartboard:
+    """
+    Attributes:
+        item (Dartboard):
+    """
+
+    item: "Dartboard"
+    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.dartboard import Dartboard
+
+        d = dict(src_dict)
+        item = Dartboard.from_dict(d.pop("item"))
+
+        wrapped_dartboard = cls(
+            item=item,
+        )
+
+        wrapped_dartboard.additional_properties = d
+        return wrapped_dartboard
+
+    @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/wrapped_doc.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.doc import Doc
+
+
+T = TypeVar("T", bound="WrappedDoc")
+
+
+@_attrs_define
+class WrappedDoc:
+    """
+    Attributes:
+        item (Doc):
+    """
+
+    item: "Doc"
+    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.doc import Doc
+
+        d = dict(src_dict)
+        item = Doc.from_dict(d.pop("item"))
+
+        wrapped_doc = cls(
+            item=item,
+        )
+
+        wrapped_doc.additional_properties = d
+        return wrapped_doc
+
+    @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/wrapped_doc_create.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.doc_create import DocCreate
+
+
+T = TypeVar("T", bound="WrappedDocCreate")
+
+
+@_attrs_define
+class WrappedDocCreate:
+    """
+    Attributes:
+        item (DocCreate):
+    """
+
+    item: "DocCreate"
+    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.doc_create import DocCreate
+
+        d = dict(src_dict)
+        item = DocCreate.from_dict(d.pop("item"))
+
+        wrapped_doc_create = cls(
+            item=item,
+        )
+
+        wrapped_doc_create.additional_properties = d
+        return wrapped_doc_create
+
+    @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/wrapped_doc_update.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.doc_update import DocUpdate
+
+
+T = TypeVar("T", bound="WrappedDocUpdate")
+
+
+@_attrs_define
+class WrappedDocUpdate:
+    """
+    Attributes:
+        item (DocUpdate):
+    """
+
+    item: "DocUpdate"
+    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.doc_update import DocUpdate
+
+        d = dict(src_dict)
+        item = DocUpdate.from_dict(d.pop("item"))
+
+        wrapped_doc_update = cls(
+            item=item,
+        )
+
+        wrapped_doc_update.additional_properties = d
+        return wrapped_doc_update
+
+    @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/wrapped_folder.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.folder import Folder
+
+
+T = TypeVar("T", bound="WrappedFolder")
+
+
+@_attrs_define
+class WrappedFolder:
+    """
+    Attributes:
+        item (Folder):
+    """
+
+    item: "Folder"
+    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.folder import Folder
+
+        d = dict(src_dict)
+        item = Folder.from_dict(d.pop("item"))
+
+        wrapped_folder = cls(
+            item=item,
+        )
+
+        wrapped_folder.additional_properties = d
+        return wrapped_folder
+
+    @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/wrapped_task.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.task import Task
+
+
+T = TypeVar("T", bound="WrappedTask")
+
+
+@_attrs_define
+class WrappedTask:
+    """
+    Attributes:
+        item (Task):
+    """
+
+    item: "Task"
+    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.task import Task
+
+        d = dict(src_dict)
+        item = Task.from_dict(d.pop("item"))
+
+        wrapped_task = cls(
+            item=item,
+        )
+
+        wrapped_task.additional_properties = d
+        return wrapped_task
+
+    @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/wrapped_task_create.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.task_create import TaskCreate
+
+
+T = TypeVar("T", bound="WrappedTaskCreate")
+
+
+@_attrs_define
+class WrappedTaskCreate:
+    """
+    Attributes:
+        item (TaskCreate):
+    """
+
+    item: "TaskCreate"
+    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.task_create import TaskCreate
+
+        d = dict(src_dict)
+        item = TaskCreate.from_dict(d.pop("item"))
+
+        wrapped_task_create = cls(
+            item=item,
+        )
+
+        wrapped_task_create.additional_properties = d
+        return wrapped_task_create
+
+    @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/wrapped_task_update.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.task_update import TaskUpdate
+
+
+T = TypeVar("T", bound="WrappedTaskUpdate")
+
+
+@_attrs_define
+class WrappedTaskUpdate:
+    """
+    Attributes:
+        item (TaskUpdate):
+    """
+
+    item: "TaskUpdate"
+    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.task_update import TaskUpdate
+
+        d = dict(src_dict)
+        item = TaskUpdate.from_dict(d.pop("item"))
+
+        wrapped_task_update = cls(
+            item=item,
+        )
+
+        wrapped_task_update.additional_properties = d
+        return wrapped_task_update
+
+    @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/wrapped_view.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.view import View
+
+
+T = TypeVar("T", bound="WrappedView")
+
+
+@_attrs_define
+class WrappedView:
+    """
+    Attributes:
+        item (View):
+    """
+
+    item: "View"
+    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.view import View
+
+        d = dict(src_dict)
+        item = View.from_dict(d.pop("item"))
+
+        wrapped_view = cls(
+            item=item,
+        )
+
+        wrapped_view.additional_properties = d
+        return wrapped_view
+
+    @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/types.py

@@ -1,7 +1,8 @@
 """Contains some shared types for properties"""
 
+from collections.abc import MutableMapping
 from http import HTTPStatus
-from typing import BinaryIO, Generic, Literal, MutableMapping, Optional, Tuple, TypeVar
+from typing import BinaryIO, Generic, Literal, Optional, TypeVar
 
 from attrs import define
 
@@ -13,7 +14,7 @@ class Unset:
 
 UNSET: Unset = Unset()
 
-FileJsonType = Tuple[Optional[str], BinaryIO, Optional[str]]
+FileJsonType = tuple[Optional[str], BinaryIO, Optional[str]]
 
 
 @define
@@ -42,4 +43,4 @@ class Response(Generic[T]):
     parsed: Optional[T]
 
 
-__all__ = ["File", "Response", "FileJsonType", "Unset", "UNSET"]
+__all__ = ["UNSET", "File", "FileJsonType", "Response", "Unset"]