minikai 0.1.2__py3-none-any.whl → 0.1.3__py3-none-any.whl

minikai/models/group_dto.py

@@ -1,38 +1,54 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import Any, TypeVar, Optional, 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
+from typing import cast, Union
+from typing import Union
+
 if TYPE_CHECKING:
-    from ..models.slim_mini_dto import SlimMiniDto
-    from ..models.user_dto import UserDto
+  from ..models.user_dto import UserDto
+  from ..models.slim_mini_dto import SlimMiniDto
+
+
+
 
 
 T = TypeVar("T", bound="GroupDto")
 
 
+
 @_attrs_define
 class GroupDto:
-    """
-    Attributes:
-        id (Union[Unset, str]):
-        name (Union[Unset, str]):
-        description (Union[None, Unset, str]):
-        workspace_id (Union[Unset, str]):
-        users (Union[Unset, list['UserDto']]):
-        minis (Union[Unset, list['SlimMiniDto']]):
-    """
+    """ 
+        Attributes:
+            id (Union[Unset, str]):
+            name (Union[Unset, str]):
+            description (Union[None, Unset, str]):
+            workspace_id (Union[Unset, str]):
+            users (Union[Unset, list['UserDto']]):
+            minis (Union[Unset, list['SlimMiniDto']]):
+     """
 
     id: Union[Unset, str] = UNSET
     name: Union[Unset, str] = UNSET
     description: Union[None, Unset, str] = UNSET
     workspace_id: Union[Unset, str] = UNSET
-    users: Union[Unset, list["UserDto"]] = UNSET
-    minis: Union[Unset, list["SlimMiniDto"]] = UNSET
+    users: Union[Unset, list['UserDto']] = UNSET
+    minis: Union[Unset, list['SlimMiniDto']] = UNSET
+
+
+
+
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.user_dto import UserDto
+        from ..models.slim_mini_dto import SlimMiniDto
         id = self.id
 
         name = self.name
@@ -52,6 +68,8 @@ class GroupDto:
                 users_item = users_item_data.to_dict()
                 users.append(users_item)
 
+
+
         minis: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.minis, Unset):
             minis = []
@@ -59,9 +77,13 @@ class GroupDto:
                 minis_item = minis_item_data.to_dict()
                 minis.append(minis_item)
 
+
+
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if id is not UNSET:
             field_dict["id"] = id
         if name is not UNSET:
@@ -77,11 +99,12 @@ class GroupDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.slim_mini_dto import SlimMiniDto
         from ..models.user_dto import UserDto
-
+        from ..models.slim_mini_dto import SlimMiniDto
         d = dict(src_dict)
         id = d.pop("id", UNSET)
 
@@ -96,22 +119,29 @@ class GroupDto:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         workspace_id = d.pop("workspaceId", UNSET)
 
         users = []
         _users = d.pop("users", UNSET)
-        for users_item_data in _users or []:
+        for users_item_data in (_users or []):
             users_item = UserDto.from_dict(users_item_data)
 
+
+
             users.append(users_item)
 
+
         minis = []
         _minis = d.pop("minis", UNSET)
-        for minis_item_data in _minis or []:
+        for minis_item_data in (_minis or []):
             minis_item = SlimMiniDto.from_dict(minis_item_data)
 
+
+
             minis.append(minis_item)
 
+
         group_dto = cls(
             id=id,
             name=name,
@@ -122,3 +152,4 @@ class GroupDto:
         )
 
         return group_dto
+

minikai/models/http_validation_problem_details.py

@@ -1,39 +1,53 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import Any, TypeVar, Optional, 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
+from typing import cast, Union
+from typing import Union
+
 if TYPE_CHECKING:
-    from ..models.http_validation_problem_details_errors import HttpValidationProblemDetailsErrors
+  from ..models.http_validation_problem_details_errors import HttpValidationProblemDetailsErrors
+
+
+
 
 
 T = TypeVar("T", bound="HttpValidationProblemDetails")
 
 
+
 @_attrs_define
 class HttpValidationProblemDetails:
-    """
-    Attributes:
-        type_ (Union[None, Unset, str]):
-        title (Union[None, Unset, str]):
-        status (Union[None, Unset, int]):
-        detail (Union[None, Unset, str]):
-        instance (Union[None, Unset, str]):
-        errors (Union[Unset, HttpValidationProblemDetailsErrors]):
-    """
+    """ 
+        Attributes:
+            type_ (Union[None, Unset, str]):
+            title (Union[None, Unset, str]):
+            status (Union[None, Unset, int]):
+            detail (Union[None, Unset, str]):
+            instance (Union[None, Unset, str]):
+            errors (Union[Unset, HttpValidationProblemDetailsErrors]):
+     """
 
     type_: Union[None, Unset, str] = UNSET
     title: Union[None, Unset, str] = UNSET
     status: Union[None, Unset, int] = UNSET
     detail: Union[None, Unset, str] = UNSET
     instance: Union[None, Unset, str] = UNSET
-    errors: Union[Unset, "HttpValidationProblemDetailsErrors"] = UNSET
+    errors: Union[Unset, 'HttpValidationProblemDetailsErrors'] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
+        from ..models.http_validation_problem_details_errors import HttpValidationProblemDetailsErrors
         type_: Union[None, Unset, str]
         if isinstance(self.type_, Unset):
             type_ = UNSET
@@ -68,9 +82,11 @@ class HttpValidationProblemDetails:
         if not isinstance(self.errors, Unset):
             errors = self.errors.to_dict()
 
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
+        field_dict.update({
+        })
         if type_ is not UNSET:
             field_dict["type"] = type_
         if title is not UNSET:
@@ -86,12 +102,12 @@ class HttpValidationProblemDetails:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.http_validation_problem_details_errors import HttpValidationProblemDetailsErrors
-
         d = dict(src_dict)
-
         def _parse_type_(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -101,6 +117,7 @@ class HttpValidationProblemDetails:
 
         type_ = _parse_type_(d.pop("type", UNSET))
 
+
         def _parse_title(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -110,6 +127,7 @@ class HttpValidationProblemDetails:
 
         title = _parse_title(d.pop("title", UNSET))
 
+
         def _parse_status(data: object) -> Union[None, Unset, int]:
             if data is None:
                 return data
@@ -119,6 +137,7 @@ class HttpValidationProblemDetails:
 
         status = _parse_status(d.pop("status", UNSET))
 
+
         def _parse_detail(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -128,6 +147,7 @@ class HttpValidationProblemDetails:
 
         detail = _parse_detail(d.pop("detail", UNSET))
 
+
         def _parse_instance(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -137,13 +157,17 @@ class HttpValidationProblemDetails:
 
         instance = _parse_instance(d.pop("instance", UNSET))
 
+
         _errors = d.pop("errors", UNSET)
         errors: Union[Unset, HttpValidationProblemDetailsErrors]
-        if isinstance(_errors, Unset):
+        if isinstance(_errors,  Unset):
             errors = UNSET
         else:
             errors = HttpValidationProblemDetailsErrors.from_dict(_errors)
 
+
+
+
         http_validation_problem_details = cls(
             type_=type_,
             title=title,
@@ -153,6 +177,7 @@ class HttpValidationProblemDetails:
             errors=errors,
         )
 
+
         http_validation_problem_details.additional_properties = d
         return http_validation_problem_details
 

minikai/models/http_validation_problem_details_errors.py

@@ -1,29 +1,52 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, cast
+from typing import Any, TypeVar, Optional, 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
+
+
+
+
+
+
 T = TypeVar("T", bound="HttpValidationProblemDetailsErrors")
 
 
+
 @_attrs_define
 class HttpValidationProblemDetailsErrors:
-    """ """
+    """ 
+     """
 
     additional_properties: dict[str, list[str]] = _attrs_field(init=False, factory=dict)
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
+        
         field_dict: dict[str, Any] = {}
         for prop_name, prop in self.additional_properties.items():
             field_dict[prop_name] = prop
 
+
+
+
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        http_validation_problem_details_errors = cls()
+        http_validation_problem_details_errors = cls(
+        )
+
 
         additional_properties = {}
         for prop_name, prop_dict in d.items():

minikai/models/json_node.py

@@ -1,36 +1,49 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+from typing import Any, TypeVar, Optional, 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
+from typing import cast, Union
+from typing import Union
+
 if TYPE_CHECKING:
-    from ..models.json_node_options import JsonNodeOptions
+  from ..models.json_node_options import JsonNodeOptions
+
+
+
 
 
 T = TypeVar("T", bound="JsonNode")
 
 
+
 @_attrs_define
 class JsonNode:
-    """The base class that represents a single node within a mutable JSON document.
+    """ The base class that represents a single node within a mutable JSON document.
+
+        Attributes:
+            options (Union['JsonNodeOptions', None, Unset]): Gets the options to control the behavior.
+            parent (Union['JsonNode', None, Unset]): Gets the parent JsonNode.
+                              If there is no parent, null is returned.
+                              A parent can either be a JsonObject or a JsonArray.
+            root (Union[Unset, JsonNode]): The base class that represents a single node within a mutable JSON document.
+     """
+
+    options: Union['JsonNodeOptions', None, Unset] = UNSET
+    parent: Union['JsonNode', None, Unset] = UNSET
+    root: Union[Unset, 'JsonNode'] = UNSET
+
+
 
-    Attributes:
-        options (Union['JsonNodeOptions', None, Unset]): Gets the options to control the behavior.
-        parent (Union['JsonNode', None, Unset]): Gets the parent JsonNode.
-                          If there is no parent, null is returned.
-                          A parent can either be a JsonObject or a JsonArray.
-        root (Union[Unset, JsonNode]): The base class that represents a single node within a mutable JSON document.
-    """
 
-    options: Union["JsonNodeOptions", None, Unset] = UNSET
-    parent: Union["JsonNode", None, Unset] = UNSET
-    root: Union[Unset, "JsonNode"] = UNSET
 
     def to_dict(self) -> dict[str, Any]:
         from ..models.json_node_options import JsonNodeOptions
-
         options: Union[None, Unset, dict[str, Any]]
         if isinstance(self.options, Unset):
             options = UNSET
@@ -51,9 +64,11 @@ class JsonNode:
         if not isinstance(self.root, Unset):
             root = self.root.to_dict()
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if options is not UNSET:
             field_dict["options"] = options
         if parent is not UNSET:
@@ -63,13 +78,13 @@ class JsonNode:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.json_node_options import JsonNodeOptions
-
         d = dict(src_dict)
-
-        def _parse_options(data: object) -> Union["JsonNodeOptions", None, Unset]:
+        def _parse_options(data: object) -> Union['JsonNodeOptions', None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -79,14 +94,17 @@ class JsonNode:
                     raise TypeError()
                 options_type_0 = JsonNodeOptions.from_dict(data)
 
+
+
                 return options_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
-            return cast(Union["JsonNodeOptions", None, Unset], data)
+            return cast(Union['JsonNodeOptions', None, Unset], data)
 
         options = _parse_options(d.pop("options", UNSET))
 
-        def _parse_parent(data: object) -> Union["JsonNode", None, Unset]:
+
+        def _parse_parent(data: object) -> Union['JsonNode', None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -96,20 +114,26 @@ class JsonNode:
                     raise TypeError()
                 parent_type_0 = JsonNode.from_dict(data)
 
+
+
                 return parent_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
-            return cast(Union["JsonNode", None, Unset], data)
+            return cast(Union['JsonNode', None, Unset], data)
 
         parent = _parse_parent(d.pop("parent", UNSET))
 
+
         _root = d.pop("root", UNSET)
         root: Union[Unset, JsonNode]
-        if isinstance(_root, Unset):
+        if isinstance(_root,  Unset):
             root = UNSET
         else:
             root = JsonNode.from_dict(_root)
 
+
+
+
         json_node = cls(
             options=options,
             parent=parent,
@@ -117,3 +141,4 @@ class JsonNode:
         )
 
         return json_node
+

minikai/models/json_node_options.py

@@ -1,35 +1,53 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Optional, 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 Union
+
+
+
+
+
+
 T = TypeVar("T", bound="JsonNodeOptions")
 
 
+
 @_attrs_define
 class JsonNodeOptions:
-    """Options to control JsonNode behavior.
+    """ Options to control JsonNode behavior.
 
-    Attributes:
-        property_name_case_insensitive (Union[Unset, bool]): Gets or sets a value that indicates whether property names
-            on JsonObject are case insensitive.
-    """
+        Attributes:
+            property_name_case_insensitive (Union[Unset, bool]): Gets or sets a value that indicates whether property names
+                on JsonObject are case insensitive.
+     """
 
     property_name_case_insensitive: Union[Unset, bool] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         property_name_case_insensitive = self.property_name_case_insensitive
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if property_name_case_insensitive is not UNSET:
             field_dict["propertyNameCaseInsensitive"] = property_name_case_insensitive
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -40,3 +58,4 @@ class JsonNodeOptions:
         )
 
         return json_node_options
+