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

minikai/models/record_tag.py

@@ -1,25 +1,37 @@
-import datetime
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union, cast
+from typing import Any, TypeVar, Optional, BinaryIO, TextIO, TYPE_CHECKING, Generator
 
 from attrs import define as _attrs_define
-from dateutil.parser import isoparse
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
 
 from ..types import UNSET, Unset
+from dateutil.parser import isoparse
+from typing import cast
+from typing import cast, Union
+from typing import Union
+import datetime
+
+
+
+
+
 
 T = TypeVar("T", bound="RecordTag")
 
 
+
 @_attrs_define
 class RecordTag:
-    """
-    Attributes:
-        key (Union[Unset, str]):
-        value_string (Union[None, Unset, str]):
-        value_number (Union[None, Unset, float]):
-        value_boolean (Union[None, Unset, bool]):
-        value_date (Union[None, Unset, datetime.datetime]):
-    """
+    """ 
+        Attributes:
+            key (Union[Unset, str]):
+            value_string (Union[None, Unset, str]):
+            value_number (Union[None, Unset, float]):
+            value_boolean (Union[None, Unset, bool]):
+            value_date (Union[None, Unset, datetime.datetime]):
+     """
 
     key: Union[Unset, str] = UNSET
     value_string: Union[None, Unset, str] = UNSET
@@ -27,6 +39,10 @@ class RecordTag:
     value_boolean: Union[None, Unset, bool] = UNSET
     value_date: Union[None, Unset, datetime.datetime] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         key = self.key
 
@@ -56,9 +72,11 @@ class RecordTag:
         else:
             value_date = self.value_date
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if key is not UNSET:
             field_dict["key"] = key
         if value_string is not UNSET:
@@ -72,6 +90,8 @@ class RecordTag:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -86,6 +106,7 @@ class RecordTag:
 
         value_string = _parse_value_string(d.pop("valueString", UNSET))
 
+
         def _parse_value_number(data: object) -> Union[None, Unset, float]:
             if data is None:
                 return data
@@ -95,6 +116,7 @@ class RecordTag:
 
         value_number = _parse_value_number(d.pop("valueNumber", UNSET))
 
+
         def _parse_value_boolean(data: object) -> Union[None, Unset, bool]:
             if data is None:
                 return data
@@ -104,6 +126,7 @@ class RecordTag:
 
         value_boolean = _parse_value_boolean(d.pop("valueBoolean", UNSET))
 
+
         def _parse_value_date(data: object) -> Union[None, Unset, datetime.datetime]:
             if data is None:
                 return data
@@ -114,13 +137,16 @@ class RecordTag:
                     raise TypeError()
                 value_date_type_0 = isoparse(data)
 
+
+
                 return value_date_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
             return cast(Union[None, Unset, datetime.datetime], data)
 
         value_date = _parse_value_date(d.pop("valueDate", UNSET))
 
+
         record_tag = cls(
             key=key,
             value_string=value_string,
@@ -130,3 +156,4 @@ class RecordTag:
         )
 
         return record_tag
+

minikai/models/record_tag_dto.py

@@ -0,0 +1,68 @@
+from collections.abc import Mapping
+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="RecordTagDto")
+
+
+
+@_attrs_define
+class RecordTagDto:
+    """ 
+        Attributes:
+            key (Union[Unset, str]):
+            value (Union[Unset, Any]):
+     """
+
+    key: Union[Unset, str] = UNSET
+    value: Union[Unset, Any] = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        key = self.key
+
+        value = self.value
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if key is not UNSET:
+            field_dict["key"] = key
+        if value is not UNSET:
+            field_dict["value"] = value
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        key = d.pop("key", UNSET)
+
+        value = d.pop("value", UNSET)
+
+        record_tag_dto = cls(
+            key=key,
+            value=value,
+        )
+
+        return record_tag_dto
+

minikai/models/slim_mini_dto.py

@@ -1,42 +1,56 @@
 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.mini_template_dto import MiniTemplateDto
-    from ..models.workspace_dto import WorkspaceDto
+  from ..models.mini_template_dto import MiniTemplateDto
+  from ..models.workspace_dto import WorkspaceDto
+
+
+
 
 
 T = TypeVar("T", bound="SlimMiniDto")
 
 
+
 @_attrs_define
 class SlimMiniDto:
-    """
-    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']]):
-    """
+    """ 
+        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']]):
+     """
 
     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
+    template: Union['MiniTemplateDto', None, Unset] = UNSET
+    workspaces: Union[Unset, list['WorkspaceDto']] = UNSET
+
+
+
+
 
     def to_dict(self) -> dict[str, Any]:
         from ..models.mini_template_dto import MiniTemplateDto
-
+        from ..models.workspace_dto import WorkspaceDto
         id = self.id
 
         name = self.name
@@ -74,9 +88,13 @@ class SlimMiniDto:
                 workspaces_item = workspaces_item_data.to_dict()
                 workspaces.append(workspaces_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:
@@ -94,11 +112,12 @@ class SlimMiniDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         from ..models.mini_template_dto import MiniTemplateDto
         from ..models.workspace_dto import WorkspaceDto
-
         d = dict(src_dict)
         id = d.pop("id", UNSET)
 
@@ -113,6 +132,7 @@ class SlimMiniDto:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         def _parse_instructions(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -122,6 +142,7 @@ class SlimMiniDto:
 
         instructions = _parse_instructions(d.pop("instructions", UNSET))
 
+
         def _parse_template_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -131,7 +152,8 @@ class SlimMiniDto:
 
         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):
@@ -141,20 +163,26 @@ class SlimMiniDto:
                     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)
 
+
         slim_mini_dto = cls(
             id=id,
             name=name,
@@ -166,3 +194,4 @@ class SlimMiniDto:
         )
 
         return slim_mini_dto
+

minikai/models/tool_dto.py

@@ -1,23 +1,33 @@
 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="ToolDto")
 
 
+
 @_attrs_define
 class ToolDto:
-    """
-    Attributes:
-        id (Union[Unset, int]):
-        name (Union[Unset, str]):
-        description (Union[Unset, str]):
-        endpoint (Union[Unset, str]):
-        schema (Union[Unset, str]):
-    """
+    """ 
+        Attributes:
+            id (Union[Unset, int]):
+            name (Union[Unset, str]):
+            description (Union[Unset, str]):
+            endpoint (Union[Unset, str]):
+            schema (Union[Unset, str]):
+     """
 
     id: Union[Unset, int] = UNSET
     name: Union[Unset, str] = UNSET
@@ -25,6 +35,10 @@ class ToolDto:
     endpoint: Union[Unset, str] = UNSET
     schema: Union[Unset, str] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         id = self.id
 
@@ -36,9 +50,11 @@ class ToolDto:
 
         schema = self.schema
 
+
         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:
@@ -52,6 +68,8 @@ class ToolDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -74,3 +92,4 @@ class ToolDto:
         )
 
         return tool_dto
+

minikai/models/update_attachments_body.py

@@ -1,26 +1,43 @@
 from collections.abc import Mapping
-from io import BytesIO
-from typing import 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
-
+import json
 from .. import types
-from ..types import UNSET, File, FileTypes, Unset
+
+from ..types import UNSET, Unset
+
+from ..types import File, FileTypes
+from ..types import UNSET, Unset
+from io import BytesIO
+from typing import cast
+from typing import cast, Union
+from typing import Union
+
+
+
+
+
 
 T = TypeVar("T", bound="UpdateAttachmentsBody")
 
 
+
 @_attrs_define
 class UpdateAttachmentsBody:
-    """
-    Attributes:
-        files (Union[None, Unset, list[File]]):
-    """
+    """ 
+        Attributes:
+            files (Union[None, Unset, list[File]]):
+     """
 
     files: Union[None, Unset, list[File]] = UNSET
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         files: Union[None, Unset, list[FileTypes]]
         if isinstance(self.files, Unset):
@@ -32,36 +49,45 @@ class UpdateAttachmentsBody:
 
                 files.append(files_type_0_item)
 
+
         else:
             files = self.files
 
+
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
-        field_dict.update({})
+        field_dict.update({
+        })
         if files is not UNSET:
             field_dict["files"] = files
 
         return field_dict
 
+
     def to_multipart(self) -> types.RequestFiles:
         files: types.RequestFiles = []
 
         if not isinstance(self.files, Unset):
             if isinstance(self.files, list):
+
                 for files_type_0_item_element in self.files:
                     files.append(("files", files_type_0_item_element.to_tuple()))
             else:
                 files.append(("files", (None, str(self.files).encode(), "text/plain")))
 
+
+
         for prop_name, prop in self.additional_properties.items():
             files.append((prop_name, (None, str(prop).encode(), "text/plain")))
 
+
+
         return files
 
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-
         def _parse_files(data: object) -> Union[None, Unset, list[File]]:
             if data is None:
                 return data
@@ -72,22 +98,28 @@ class UpdateAttachmentsBody:
                     raise TypeError()
                 files_type_0 = []
                 _files_type_0 = data
-                for files_type_0_item_data in _files_type_0:
-                    files_type_0_item = File(payload=BytesIO(files_type_0_item_data))
+                for files_type_0_item_data in (_files_type_0):
+                    files_type_0_item = File(
+                         payload = BytesIO(files_type_0_item_data)
+                    )
+
+
 
                     files_type_0.append(files_type_0_item)
 
                 return files_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
             return cast(Union[None, Unset, list[File]], data)
 
         files = _parse_files(d.pop("files", UNSET))
 
+
         update_attachments_body = cls(
             files=files,
         )
 
+
         update_attachments_body.additional_properties = d
         return update_attachments_body
 

minikai/models/update_group_command.py

@@ -1,28 +1,44 @@
 from collections.abc import Mapping
-from typing import 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
+
+
+
+
+
+
 T = TypeVar("T", bound="UpdateGroupCommand")
 
 
+
 @_attrs_define
 class UpdateGroupCommand:
-    """
-    Attributes:
-        group_id (Union[Unset, str]):
-        name (Union[None, Unset, str]):
-        user_ids (Union[None, Unset, list[str]]):
-        mini_ids (Union[None, Unset, list[int]]):
-    """
+    """ 
+        Attributes:
+            group_id (Union[Unset, str]):
+            name (Union[None, Unset, str]):
+            user_ids (Union[None, Unset, list[str]]):
+            mini_ids (Union[None, Unset, list[int]]):
+     """
 
     group_id: Union[Unset, str] = UNSET
     name: Union[None, Unset, str] = UNSET
     user_ids: Union[None, Unset, list[str]] = UNSET
     mini_ids: Union[None, Unset, list[int]] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         group_id = self.group_id
 
@@ -38,6 +54,7 @@ class UpdateGroupCommand:
         elif isinstance(self.user_ids, list):
             user_ids = self.user_ids
 
+
         else:
             user_ids = self.user_ids
 
@@ -47,12 +64,15 @@ class UpdateGroupCommand:
         elif isinstance(self.mini_ids, list):
             mini_ids = self.mini_ids
 
+
         else:
             mini_ids = self.mini_ids
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if group_id is not UNSET:
             field_dict["groupId"] = group_id
         if name is not UNSET:
@@ -64,6 +84,8 @@ class UpdateGroupCommand:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -78,6 +100,7 @@ class UpdateGroupCommand:
 
         name = _parse_name(d.pop("name", UNSET))
 
+
         def _parse_user_ids(data: object) -> Union[None, Unset, list[str]]:
             if data is None:
                 return data
@@ -89,12 +112,13 @@ class UpdateGroupCommand:
                 user_ids_type_0 = cast(list[str], data)
 
                 return user_ids_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
             return cast(Union[None, Unset, list[str]], data)
 
         user_ids = _parse_user_ids(d.pop("userIds", UNSET))
 
+
         def _parse_mini_ids(data: object) -> Union[None, Unset, list[int]]:
             if data is None:
                 return data
@@ -106,12 +130,13 @@ class UpdateGroupCommand:
                 mini_ids_type_0 = cast(list[int], data)
 
                 return mini_ids_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
             return cast(Union[None, Unset, list[int]], data)
 
         mini_ids = _parse_mini_ids(d.pop("miniIds", UNSET))
 
+
         update_group_command = cls(
             group_id=group_id,
             name=name,
@@ -120,3 +145,4 @@ class UpdateGroupCommand:
         )
 
         return update_group_command
+