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

minikai/models/record_tag.py

@@ -0,0 +1,159 @@
+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 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]):
+     """
+
+    key: Union[Unset, str] = UNSET
+    value_string: Union[None, Unset, str] = UNSET
+    value_number: Union[None, Unset, float] = UNSET
+    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
+
+        value_string: Union[None, Unset, str]
+        if isinstance(self.value_string, Unset):
+            value_string = UNSET
+        else:
+            value_string = self.value_string
+
+        value_number: Union[None, Unset, float]
+        if isinstance(self.value_number, Unset):
+            value_number = UNSET
+        else:
+            value_number = self.value_number
+
+        value_boolean: Union[None, Unset, bool]
+        if isinstance(self.value_boolean, Unset):
+            value_boolean = UNSET
+        else:
+            value_boolean = self.value_boolean
+
+        value_date: Union[None, Unset, str]
+        if isinstance(self.value_date, Unset):
+            value_date = UNSET
+        elif isinstance(self.value_date, datetime.datetime):
+            value_date = self.value_date.isoformat()
+        else:
+            value_date = self.value_date
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if key is not UNSET:
+            field_dict["key"] = key
+        if value_string is not UNSET:
+            field_dict["valueString"] = value_string
+        if value_number is not UNSET:
+            field_dict["valueNumber"] = value_number
+        if value_boolean is not UNSET:
+            field_dict["valueBoolean"] = value_boolean
+        if value_date is not UNSET:
+            field_dict["valueDate"] = value_date
+
+        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)
+
+        def _parse_value_string(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)
+
+        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
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        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
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, bool], data)
+
+        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
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                value_date_type_0 = isoparse(data)
+
+
+
+                return value_date_type_0
+            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,
+            value_number=value_number,
+            value_boolean=value_boolean,
+            value_date=value_date,
+        )
+
+        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