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

minikai/models/__init__.py

@@ -1,10 +1,11 @@
-"""Contains all the data models used in inputs/outputs"""
+""" Contains all the data models used in inputs/outputs """
 
 from .add_attachments_body import AddAttachmentsBody
 from .create_group_command import CreateGroupCommand
 from .create_mini_command import CreateMiniCommand
 from .create_record_command import CreateRecordCommand
 from .create_record_command_tags import CreateRecordCommandTags
+from .cursor_paginated_list_of_record_dto import CursorPaginatedListOfRecordDto
 from .document_file_dto import DocumentFileDto
 from .document_file_metadata_dto import DocumentFileMetadataDto
 from .form_field import FormField
@@ -31,7 +32,8 @@ from .record_dto import RecordDto
 from .record_dto_tags import RecordDtoTags
 from .record_relation import RecordRelation
 from .record_relation_dto import RecordRelationDto
-from .record_tags import RecordTags
+from .record_tag import RecordTag
+from .record_tag_dto import RecordTagDto
 from .slim_mini_dto import SlimMiniDto
 from .tool_dto import ToolDto
 from .update_attachments_body import UpdateAttachmentsBody
@@ -50,6 +52,7 @@ __all__ = (
     "CreateMiniCommand",
     "CreateRecordCommand",
     "CreateRecordCommandTags",
+    "CursorPaginatedListOfRecordDto",
     "DocumentFileDto",
     "DocumentFileMetadataDto",
     "FormField",
@@ -76,7 +79,8 @@ __all__ = (
     "RecordDtoTags",
     "RecordRelation",
     "RecordRelationDto",
-    "RecordTags",
+    "RecordTag",
+    "RecordTagDto",
     "SlimMiniDto",
     "ToolDto",
     "UpdateAttachmentsBody",

minikai/models/add_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="AddAttachmentsBody")
 
 
+
 @_attrs_define
 class AddAttachmentsBody:
-    """
-    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 AddAttachmentsBody:
 
                 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 AddAttachmentsBody:
                     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))
 
+
         add_attachments_body = cls(
             files=files,
         )
 
+
         add_attachments_body.additional_properties = d
         return add_attachments_body
 

minikai/models/create_group_command.py

@@ -1,26 +1,42 @@
 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="CreateGroupCommand")
 
 
+
 @_attrs_define
 class CreateGroupCommand:
-    """
-    Attributes:
-        name (Union[Unset, str]):
-        user_ids (Union[None, Unset, list[str]]):
-        mini_ids (Union[None, Unset, list[int]]):
-    """
+    """ 
+        Attributes:
+            name (Union[Unset, str]):
+            user_ids (Union[None, Unset, list[str]]):
+            mini_ids (Union[None, Unset, list[int]]):
+     """
 
     name: Union[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]:
         name = self.name
 
@@ -30,6 +46,7 @@ class CreateGroupCommand:
         elif isinstance(self.user_ids, list):
             user_ids = self.user_ids
 
+
         else:
             user_ids = self.user_ids
 
@@ -39,12 +56,15 @@ class CreateGroupCommand:
         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 name is not UNSET:
             field_dict["name"] = name
         if user_ids is not UNSET:
@@ -54,6 +74,8 @@ class CreateGroupCommand:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -70,12 +92,13 @@ class CreateGroupCommand:
                 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
@@ -87,12 +110,13 @@ class CreateGroupCommand:
                 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))
 
+
         create_group_command = cls(
             name=name,
             user_ids=user_ids,
@@ -100,3 +124,4 @@ class CreateGroupCommand:
         )
 
         return create_group_command
+

minikai/models/create_mini_command.py

@@ -1,23 +1,34 @@
 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, Union
+from typing import Union
+
+
+
+
+
+
 T = TypeVar("T", bound="CreateMiniCommand")
 
 
+
 @_attrs_define
 class CreateMiniCommand:
-    """
-    Attributes:
-        name (Union[Unset, str]):
-        description (Union[None, Unset, str]):
-        template_id (Union[None, Unset, str]):
-        external_id (Union[None, Unset, str]):
-        external_source (Union[None, Unset, str]):
-    """
+    """ 
+        Attributes:
+            name (Union[Unset, str]):
+            description (Union[None, Unset, str]):
+            template_id (Union[None, Unset, str]):
+            external_id (Union[None, Unset, str]):
+            external_source (Union[None, Unset, str]):
+     """
 
     name: Union[Unset, str] = UNSET
     description: Union[None, Unset, str] = UNSET
@@ -25,6 +36,10 @@ class CreateMiniCommand:
     external_id: Union[None, Unset, str] = UNSET
     external_source: Union[None, Unset, str] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         name = self.name
 
@@ -52,9 +67,11 @@ class CreateMiniCommand:
         else:
             external_source = self.external_source
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if name is not UNSET:
             field_dict["name"] = name
         if description is not UNSET:
@@ -68,6 +85,8 @@ class CreateMiniCommand:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -82,6 +101,7 @@ class CreateMiniCommand:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         def _parse_template_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -91,6 +111,7 @@ class CreateMiniCommand:
 
         template_id = _parse_template_id(d.pop("templateId", UNSET))
 
+
         def _parse_external_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -100,6 +121,7 @@ class CreateMiniCommand:
 
         external_id = _parse_external_id(d.pop("externalId", UNSET))
 
+
         def _parse_external_source(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -109,6 +131,7 @@ class CreateMiniCommand:
 
         external_source = _parse_external_source(d.pop("externalSource", UNSET))
 
+
         create_mini_command = cls(
             name=name,
             description=description,
@@ -118,3 +141,4 @@ class CreateMiniCommand:
         )
 
         return create_mini_command
+

minikai/models/create_record_command.py

@@ -1,54 +1,70 @@
-import datetime
 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 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
+
 if TYPE_CHECKING:
-    from ..models.create_record_command_tags import CreateRecordCommandTags
-    from ..models.json_node import JsonNode
-    from ..models.record_authorization_dto import RecordAuthorizationDto
-    from ..models.record_relation_dto import RecordRelationDto
+  from ..models.record_relation_dto import RecordRelationDto
+  from ..models.json_node import JsonNode
+  from ..models.create_record_command_tags import CreateRecordCommandTags
+  from ..models.record_authorization_dto import RecordAuthorizationDto
+
+
+
 
 
 T = TypeVar("T", bound="CreateRecordCommand")
 
 
+
 @_attrs_define
 class CreateRecordCommand:
-    """
-    Attributes:
-        title (Union[Unset, str]):
-        description (Union[None, Unset, str]):
-        mini_id (Union[None, Unset, str]):
-        event_date (Union[None, Unset, datetime.datetime]):
-        schema (Union['JsonNode', None, Unset]):
-        content (Union['JsonNode', None, Unset]):
-        relations (Union[Unset, list['RecordRelationDto']]):
-        external_uri (Union[None, Unset, str]):
-        labels (Union[Unset, list[str]]):
-        tags (Union[Unset, CreateRecordCommandTags]):
-        authorization (Union[Unset, RecordAuthorizationDto]):
-    """
+    """ 
+        Attributes:
+            title (Union[Unset, str]):
+            description (Union[None, Unset, str]):
+            mini_id (Union[None, Unset, str]):
+            event_date (Union[None, Unset, datetime.datetime]):
+            schema (Union['JsonNode', None, Unset]):
+            content (Union['JsonNode', None, Unset]):
+            relations (Union[Unset, list['RecordRelationDto']]):
+            external_uri (Union[None, Unset, str]):
+            labels (Union[Unset, list[str]]):
+            tags (Union[Unset, CreateRecordCommandTags]):
+            authorization (Union[Unset, RecordAuthorizationDto]):
+     """
 
     title: Union[Unset, str] = UNSET
     description: Union[None, Unset, str] = UNSET
     mini_id: Union[None, Unset, str] = UNSET
     event_date: Union[None, Unset, datetime.datetime] = UNSET
-    schema: Union["JsonNode", None, Unset] = UNSET
-    content: Union["JsonNode", None, Unset] = UNSET
-    relations: Union[Unset, list["RecordRelationDto"]] = UNSET
+    schema: Union['JsonNode', None, Unset] = UNSET
+    content: Union['JsonNode', None, Unset] = UNSET
+    relations: Union[Unset, list['RecordRelationDto']] = UNSET
     external_uri: Union[None, Unset, str] = UNSET
     labels: Union[Unset, list[str]] = UNSET
-    tags: Union[Unset, "CreateRecordCommandTags"] = UNSET
-    authorization: Union[Unset, "RecordAuthorizationDto"] = UNSET
+    tags: Union[Unset, 'CreateRecordCommandTags'] = UNSET
+    authorization: Union[Unset, 'RecordAuthorizationDto'] = UNSET
+
+
+
+
 
     def to_dict(self) -> dict[str, Any]:
+        from ..models.record_relation_dto import RecordRelationDto
         from ..models.json_node import JsonNode
-
+        from ..models.create_record_command_tags import CreateRecordCommandTags
+        from ..models.record_authorization_dto import RecordAuthorizationDto
         title = self.title
 
         description: Union[None, Unset, str]
@@ -94,6 +110,8 @@ class CreateRecordCommand:
                 relations_item = relations_item_data.to_dict()
                 relations.append(relations_item)
 
+
+
         external_uri: Union[None, Unset, str]
         if isinstance(self.external_uri, Unset):
             external_uri = UNSET
@@ -104,6 +122,8 @@ class CreateRecordCommand:
         if not isinstance(self.labels, Unset):
             labels = self.labels
 
+
+
         tags: Union[Unset, dict[str, Any]] = UNSET
         if not isinstance(self.tags, Unset):
             tags = self.tags.to_dict()
@@ -112,9 +132,11 @@ class CreateRecordCommand:
         if not isinstance(self.authorization, Unset):
             authorization = self.authorization.to_dict()
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if title is not UNSET:
             field_dict["title"] = title
         if description is not UNSET:
@@ -140,13 +162,14 @@ class CreateRecordCommand:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
-        from ..models.create_record_command_tags import CreateRecordCommandTags
+        from ..models.record_relation_dto import RecordRelationDto
         from ..models.json_node import JsonNode
+        from ..models.create_record_command_tags import CreateRecordCommandTags
         from ..models.record_authorization_dto import RecordAuthorizationDto
-        from ..models.record_relation_dto import RecordRelationDto
-
         d = dict(src_dict)
         title = d.pop("title", UNSET)
 
@@ -159,6 +182,7 @@ class CreateRecordCommand:
 
         description = _parse_description(d.pop("description", UNSET))
 
+
         def _parse_mini_id(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -168,6 +192,7 @@ class CreateRecordCommand:
 
         mini_id = _parse_mini_id(d.pop("miniId", UNSET))
 
+
         def _parse_event_date(data: object) -> Union[None, Unset, datetime.datetime]:
             if data is None:
                 return data
@@ -178,14 +203,17 @@ class CreateRecordCommand:
                     raise TypeError()
                 event_date_type_0 = isoparse(data)
 
+
+
                 return event_date_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
             return cast(Union[None, Unset, datetime.datetime], data)
 
         event_date = _parse_event_date(d.pop("eventDate", UNSET))
 
-        def _parse_schema(data: object) -> Union["JsonNode", None, Unset]:
+
+        def _parse_schema(data: object) -> Union['JsonNode', None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -195,14 +223,17 @@ class CreateRecordCommand:
                     raise TypeError()
                 schema_type_0 = JsonNode.from_dict(data)
 
+
+
                 return schema_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
-            return cast(Union["JsonNode", None, Unset], data)
+            return cast(Union['JsonNode', None, Unset], data)
 
         schema = _parse_schema(d.pop("schema", UNSET))
 
-        def _parse_content(data: object) -> Union["JsonNode", None, Unset]:
+
+        def _parse_content(data: object) -> Union['JsonNode', None, Unset]:
             if data is None:
                 return data
             if isinstance(data, Unset):
@@ -212,20 +243,26 @@ class CreateRecordCommand:
                     raise TypeError()
                 content_type_0 = JsonNode.from_dict(data)
 
+
+
                 return content_type_0
-            except:  # noqa: E722
+            except: # noqa: E722
                 pass
-            return cast(Union["JsonNode", None, Unset], data)
+            return cast(Union['JsonNode', None, Unset], data)
 
         content = _parse_content(d.pop("content", UNSET))
 
+
         relations = []
         _relations = d.pop("relations", UNSET)
-        for relations_item_data in _relations or []:
+        for relations_item_data in (_relations or []):
             relations_item = RecordRelationDto.from_dict(relations_item_data)
 
+
+
             relations.append(relations_item)
 
+
         def _parse_external_uri(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -235,22 +272,30 @@ class CreateRecordCommand:
 
         external_uri = _parse_external_uri(d.pop("externalUri", UNSET))
 
+
         labels = cast(list[str], d.pop("labels", UNSET))
 
+
         _tags = d.pop("tags", UNSET)
         tags: Union[Unset, CreateRecordCommandTags]
-        if isinstance(_tags, Unset):
+        if isinstance(_tags,  Unset):
             tags = UNSET
         else:
             tags = CreateRecordCommandTags.from_dict(_tags)
 
+
+
+
         _authorization = d.pop("authorization", UNSET)
         authorization: Union[Unset, RecordAuthorizationDto]
-        if isinstance(_authorization, Unset):
+        if isinstance(_authorization,  Unset):
             authorization = UNSET
         else:
             authorization = RecordAuthorizationDto.from_dict(_authorization)
 
+
+
+
         create_record_command = cls(
             title=title,
             description=description,
@@ -266,3 +311,4 @@ class CreateRecordCommand:
         )
 
         return create_record_command
+