minikai 0.1.2__py3-none-any.whl → 0.1.4__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/mini_dto.py

@@ -1,45 +1,60 @@
 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.document_file_dto import DocumentFileDto
-    from ..models.mini_template_dto import MiniTemplateDto
-    from ..models.workspace_dto import WorkspaceDto
+  from ..models.mini_template_dto import MiniTemplateDto
+  from ..models.workspace_dto import WorkspaceDto
+  from ..models.document_file_dto import DocumentFileDto
+
+
+
 
 
 T = TypeVar("T", bound="MiniDto")
 
 
+
 @_attrs_define
 class MiniDto:
-    """
-    Attributes:
-        id (Union[Unset, int]):
-        name (Union[Unset, str]):
-        description (Union[None, Unset, str]):
-        instructions (Union[None, Unset, str]):
-        template_id (Union[None, Unset, str]):
-        template (Union['MiniTemplateDto', None, Unset]):
-        workspaces (Union[Unset, list['WorkspaceDto']]):
-        document_files (Union[Unset, list['DocumentFileDto']]):
-    """
+    """ 
+        Attributes:
+            id (Union[Unset, int]):
+            name (Union[Unset, str]):
+            description (Union[None, Unset, str]):
+            instructions (Union[None, Unset, str]):
+            template_id (Union[None, Unset, str]):
+            template (Union['MiniTemplateDto', None, Unset]):
+            workspaces (Union[Unset, list['WorkspaceDto']]):
+            document_files (Union[Unset, list['DocumentFileDto']]):
+     """
 
     id: Union[Unset, int] = UNSET
     name: Union[Unset, str] = UNSET
     description: Union[None, Unset, str] = UNSET
     instructions: Union[None, Unset, str] = UNSET
     template_id: Union[None, Unset, str] = UNSET
-    template: Union["MiniTemplateDto", None, Unset] = UNSET
-    workspaces: Union[Unset, list["WorkspaceDto"]] = UNSET
-    document_files: Union[Unset, list["DocumentFileDto"]] = UNSET
+    template: Union['MiniTemplateDto', None, Unset] = UNSET
+    workspaces: Union[Unset, list['WorkspaceDto']] = UNSET
+    document_files: Union[Unset, list['DocumentFileDto']] = UNSET
+
+
+
+
 
     def to_dict(self) -> dict[str, Any]:
         from ..models.mini_template_dto import MiniTemplateDto
-
+        from ..models.workspace_dto import WorkspaceDto
+        from ..models.document_file_dto import DocumentFileDto
         id = self.id
 
         name = self.name
@@ -77,6 +92,8 @@ class MiniDto:
                 workspaces_item = workspaces_item_data.to_dict()
                 workspaces.append(workspaces_item)
 
+
+
         document_files: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.document_files, Unset):
             document_files = []
@@ -84,9 +101,13 @@ class MiniDto:
                 document_files_item = document_files_item_data.to_dict()
                 document_files.append(document_files_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:
@@ -106,12 +127,13 @@ class MiniDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.document_file_dto import DocumentFileDto
         from ..models.mini_template_dto import MiniTemplateDto
         from ..models.workspace_dto import WorkspaceDto
-
+        from ..models.document_file_dto import DocumentFileDto
         d = dict(src_dict)
         id = d.pop("id", UNSET)
 
@@ -126,6 +148,7 @@ class MiniDto:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         def _parse_instructions(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -135,6 +158,7 @@ class MiniDto:
 
         instructions = _parse_instructions(d.pop("instructions", UNSET))
 
+
         def _parse_template_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -144,7 +168,8 @@ class MiniDto:
 
         template_id = _parse_template_id(d.pop("templateId", UNSET))
 
-        def _parse_template(data: object) -> Union["MiniTemplateDto", None, Unset]:
+
+        def _parse_template(data: object) -> Union['MiniTemplateDto', None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -154,27 +179,36 @@ class MiniDto:
                     raise TypeError()
                 template_type_0 = MiniTemplateDto.from_dict(data)
 
+
+
                 return template_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
-            return cast(Union["MiniTemplateDto", None, Unset], data)
+            return cast(Union['MiniTemplateDto', None, Unset], data)
 
         template = _parse_template(d.pop("template", UNSET))
 
+
         workspaces = []
         _workspaces = d.pop("workspaces", UNSET)
-        for workspaces_item_data in _workspaces or []:
+        for workspaces_item_data in (_workspaces or []):
             workspaces_item = WorkspaceDto.from_dict(workspaces_item_data)
 
+
+
             workspaces.append(workspaces_item)
 
+
         document_files = []
         _document_files = d.pop("documentFiles", UNSET)
-        for document_files_item_data in _document_files or []:
+        for document_files_item_data in (_document_files or []):
             document_files_item = DocumentFileDto.from_dict(document_files_item_data)
 
+
+
             document_files.append(document_files_item)
 
+
         mini_dto = cls(
             id=id,
             name=name,
@@ -187,3 +221,4 @@ class MiniDto:
         )
 
         return mini_dto
+

minikai/models/mini_template_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.tool_dto import ToolDto
-    from ..models.workspace_dto import WorkspaceDto
+  from ..models.tool_dto import ToolDto
+  from ..models.workspace_dto import WorkspaceDto
+
+
+
 
 
 T = TypeVar("T", bound="MiniTemplateDto")
 
 
+
 @_attrs_define
 class MiniTemplateDto:
-    """
-    Attributes:
-        id (Union[Unset, str]):
-        name (Union[Unset, str]):
-        description (Union[None, Unset, str]):
-        instructions (Union[None, Unset, str]):
-        workspaces (Union[Unset, list['WorkspaceDto']]):
-        tools (Union[Unset, list['ToolDto']]):
-    """
+    """ 
+        Attributes:
+            id (Union[Unset, str]):
+            name (Union[Unset, str]):
+            description (Union[None, Unset, str]):
+            instructions (Union[None, Unset, str]):
+            workspaces (Union[Unset, list['WorkspaceDto']]):
+            tools (Union[Unset, list['ToolDto']]):
+     """
 
     id: Union[Unset, str] = UNSET
     name: Union[Unset, str] = UNSET
     description: Union[None, Unset, str] = UNSET
     instructions: Union[None, Unset, str] = UNSET
-    workspaces: Union[Unset, list["WorkspaceDto"]] = UNSET
-    tools: Union[Unset, list["ToolDto"]] = UNSET
+    workspaces: Union[Unset, list['WorkspaceDto']] = UNSET
+    tools: Union[Unset, list['ToolDto']] = UNSET
+
+
+
+
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.tool_dto import ToolDto
+        from ..models.workspace_dto import WorkspaceDto
         id = self.id
 
         name = self.name
@@ -56,6 +72,8 @@ class MiniTemplateDto:
                 workspaces_item = workspaces_item_data.to_dict()
                 workspaces.append(workspaces_item)
 
+
+
         tools: Union[Unset, list[dict[str, Any]]] = UNSET
         if not isinstance(self.tools, Unset):
             tools = []
@@ -63,9 +81,13 @@ class MiniTemplateDto:
                 tools_item = tools_item_data.to_dict()
                 tools.append(tools_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:
@@ -81,11 +103,12 @@ class MiniTemplateDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.tool_dto import ToolDto
         from ..models.workspace_dto import WorkspaceDto
-
         d = dict(src_dict)
         id = d.pop("id", UNSET)
 
@@ -100,6 +123,7 @@ class MiniTemplateDto:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         def _parse_instructions(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -109,20 +133,27 @@ class MiniTemplateDto:
 
         instructions = _parse_instructions(d.pop("instructions", UNSET))
 
+
         workspaces = []
         _workspaces = d.pop("workspaces", UNSET)
-        for workspaces_item_data in _workspaces or []:
+        for workspaces_item_data in (_workspaces or []):
             workspaces_item = WorkspaceDto.from_dict(workspaces_item_data)
 
+
+
             workspaces.append(workspaces_item)
 
+
         tools = []
         _tools = d.pop("tools", UNSET)
-        for tools_item_data in _tools or []:
+        for tools_item_data in (_tools or []):
             tools_item = ToolDto.from_dict(tools_item_data)
 
+
+
             tools.append(tools_item)
 
+
         mini_template_dto = cls(
             id=id,
             name=name,
@@ -133,3 +164,4 @@ class MiniTemplateDto:
         )
 
         return mini_template_dto
+