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

minikai/models/create_record_command_tags.py

@@ -1,28 +1,47 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar
+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
+
+
+
+
+
+
+
 T = TypeVar("T", bound="CreateRecordCommandTags")
 
 
+
 @_attrs_define
 class CreateRecordCommandTags:
-    """ """
+    """ 
+     """
 
     additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
+        
         field_dict: dict[str, Any] = {}
         field_dict.update(self.additional_properties)
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-        create_record_command_tags = cls()
+        create_record_command_tags = cls(
+        )
+
 
         create_record_command_tags.additional_properties = d
         return create_record_command_tags

minikai/models/cursor_paginated_list_of_record_dto.py

@@ -0,0 +1,122 @@
+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 cast
+from typing import cast, Union
+from typing import Union
+
+if TYPE_CHECKING:
+  from ..models.record_dto import RecordDto
+
+
+
+
+
+T = TypeVar("T", bound="CursorPaginatedListOfRecordDto")
+
+
+
+@_attrs_define
+class CursorPaginatedListOfRecordDto:
+    """ 
+        Attributes:
+            items (Union[Unset, list['RecordDto']]):
+            before_cursor (Union[None, Unset, str]):
+            after_cursor (Union[None, Unset, str]):
+     """
+
+    items: Union[Unset, list['RecordDto']] = UNSET
+    before_cursor: Union[None, Unset, str] = UNSET
+    after_cursor: Union[None, Unset, str] = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.record_dto import RecordDto
+        items: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.items, Unset):
+            items = []
+            for items_item_data in self.items:
+                items_item = items_item_data.to_dict()
+                items.append(items_item)
+
+
+
+        before_cursor: Union[None, Unset, str]
+        if isinstance(self.before_cursor, Unset):
+            before_cursor = UNSET
+        else:
+            before_cursor = self.before_cursor
+
+        after_cursor: Union[None, Unset, str]
+        if isinstance(self.after_cursor, Unset):
+            after_cursor = UNSET
+        else:
+            after_cursor = self.after_cursor
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+        })
+        if items is not UNSET:
+            field_dict["items"] = items
+        if before_cursor is not UNSET:
+            field_dict["beforeCursor"] = before_cursor
+        if after_cursor is not UNSET:
+            field_dict["afterCursor"] = after_cursor
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.record_dto import RecordDto
+        d = dict(src_dict)
+        items = []
+        _items = d.pop("items", UNSET)
+        for items_item_data in (_items or []):
+            items_item = RecordDto.from_dict(items_item_data)
+
+
+
+            items.append(items_item)
+
+
+        def _parse_before_cursor(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)
+
+        before_cursor = _parse_before_cursor(d.pop("beforeCursor", UNSET))
+
+
+        def _parse_after_cursor(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)
+
+        after_cursor = _parse_after_cursor(d.pop("afterCursor", UNSET))
+
+
+        cursor_paginated_list_of_record_dto = cls(
+            items=items,
+            before_cursor=before_cursor,
+            after_cursor=after_cursor,
+        )
+
+        return cursor_paginated_list_of_record_dto
+

minikai/models/document_file_dto.py

@@ -1,26 +1,37 @@
 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="DocumentFileDto")
 
 
+
 @_attrs_define
 class DocumentFileDto:
-    """
-    Attributes:
-        id (Union[Unset, int]):
-        file_id (Union[Unset, str]):
-        doc_file_id (Union[Unset, str]):
-        name (Union[None, Unset, str]):
-        content_type (Union[None, Unset, str]):
-        file_extension (Union[None, Unset, str]):
-        size (Union[Unset, int]):
-        workspace_id (Union[None, Unset, str]):
-    """
+    """ 
+        Attributes:
+            id (Union[Unset, int]):
+            file_id (Union[Unset, str]):
+            doc_file_id (Union[Unset, str]):
+            name (Union[None, Unset, str]):
+            content_type (Union[None, Unset, str]):
+            file_extension (Union[None, Unset, str]):
+            size (Union[Unset, int]):
+            workspace_id (Union[None, Unset, str]):
+     """
 
     id: Union[Unset, int] = UNSET
     file_id: Union[Unset, str] = UNSET
@@ -31,6 +42,10 @@ class DocumentFileDto:
     size: Union[Unset, int] = UNSET
     workspace_id: Union[None, Unset, str] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         id = self.id
 
@@ -64,9 +79,11 @@ class DocumentFileDto:
         else:
             workspace_id = self.workspace_id
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if id is not UNSET:
             field_dict["id"] = id
         if file_id is not UNSET:
@@ -86,6 +103,8 @@ class DocumentFileDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -104,6 +123,7 @@ class DocumentFileDto:
 
         name = _parse_name(d.pop("name", UNSET))
 
+
         def _parse_content_type(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -113,6 +133,7 @@ class DocumentFileDto:
 
         content_type = _parse_content_type(d.pop("contentType", UNSET))
 
+
         def _parse_file_extension(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -122,6 +143,7 @@ class DocumentFileDto:
 
         file_extension = _parse_file_extension(d.pop("fileExtension", UNSET))
 
+
         size = d.pop("size", UNSET)
 
         def _parse_workspace_id(data: object) -> Union[None, Unset, str]:
@@ -133,6 +155,7 @@ class DocumentFileDto:
 
         workspace_id = _parse_workspace_id(d.pop("workspaceId", UNSET))
 
+
         document_file_dto = cls(
             id=id,
             file_id=file_id,
@@ -145,3 +168,4 @@ class DocumentFileDto:
         )
 
         return document_file_dto
+

minikai/models/document_file_metadata_dto.py

@@ -1,22 +1,37 @@
 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="DocumentFileMetadataDto")
 
 
+
 @_attrs_define
 class DocumentFileMetadataDto:
-    """
-    Attributes:
-        content_hash (Union[None, Unset, str]):
-    """
+    """ 
+        Attributes:
+            content_hash (Union[None, Unset, str]):
+     """
 
     content_hash: Union[None, Unset, str] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         content_hash: Union[None, Unset, str]
         if isinstance(self.content_hash, Unset):
@@ -24,18 +39,21 @@ class DocumentFileMetadataDto:
         else:
             content_hash = self.content_hash
 
+
         field_dict: dict[str, Any] = {}
 
-        field_dict.update({})
+        field_dict.update({
+        })
         if content_hash is not UNSET:
             field_dict["contentHash"] = content_hash
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
-
         def _parse_content_hash(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -45,8 +63,10 @@ class DocumentFileMetadataDto:
 
         content_hash = _parse_content_hash(d.pop("contentHash", UNSET))
 
+
         document_file_metadata_dto = cls(
             content_hash=content_hash,
         )
 
         return document_file_metadata_dto
+

minikai/models/form_field.py

@@ -1,30 +1,46 @@
-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="FormField")
 
 
+
 @_attrs_define
 class FormField:
-    """
-    Attributes:
-        key (Union[Unset, str]):
-        value_string (Union[None, Unset, str]):
-        value_number (Union[None, Unset, float]):
-        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_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_date: Union[None, Unset, datetime.datetime] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         key = self.key
 
@@ -48,9 +64,11 @@ class FormField:
         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:
@@ -62,6 +80,8 @@ class FormField:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -76,6 +96,7 @@ class FormField:
 
         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
@@ -85,6 +106,7 @@ class FormField:
 
         value_number = _parse_value_number(d.pop("valueNumber", UNSET))
 
+
         def _parse_value_date(data: object) -> Union[None, Unset, datetime.datetime]:
             if data is None:
                 return data
@@ -95,13 +117,16 @@ class FormField:
                     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))
 
+
         form_field = cls(
             key=key,
             value_string=value_string,
@@ -110,3 +135,4 @@ class FormField:
         )
 
         return form_field
+

minikai/models/form_field_dto.py

@@ -1,27 +1,40 @@
-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 ..models.form_field_type import FormFieldType, check_form_field_type
+from ..models.form_field_type import check_form_field_type
+from ..models.form_field_type import FormFieldType
 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="FormFieldDto")
 
 
+
 @_attrs_define
 class FormFieldDto:
-    """
-    Attributes:
-        key (Union[Unset, str]):
-        value_string (Union[None, Unset, str]):
-        value_number (Union[None, Unset, float]):
-        value_date (Union[None, Unset, datetime.datetime]):
-        value (Union[None, Unset, str]):
-        type_ (Union[Unset, FormFieldType]):
-    """
+    """ 
+        Attributes:
+            key (Union[Unset, str]):
+            value_string (Union[None, Unset, str]):
+            value_number (Union[None, Unset, float]):
+            value_date (Union[None, Unset, datetime.datetime]):
+            value (Union[None, Unset, str]):
+            type_ (Union[Unset, FormFieldType]):
+     """
 
     key: Union[Unset, str] = UNSET
     value_string: Union[None, Unset, str] = UNSET
@@ -30,6 +43,10 @@ class FormFieldDto:
     value: Union[None, Unset, str] = UNSET
     type_: Union[Unset, FormFieldType] = UNSET
 
+
+
+
+
     def to_dict(self) -> dict[str, Any]:
         key = self.key
 
@@ -63,9 +80,12 @@ class FormFieldDto:
         if not isinstance(self.type_, Unset):
             type_ = self.type_
 
+
+
         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:
@@ -81,6 +101,8 @@ class FormFieldDto:
 
         return field_dict
 
+
+
     @classmethod
     def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
         d = dict(src_dict)
@@ -95,6 +117,7 @@ class FormFieldDto:
 
         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
@@ -104,6 +127,7 @@ class FormFieldDto:
 
         value_number = _parse_value_number(d.pop("valueNumber", UNSET))
 
+
         def _parse_value_date(data: object) -> Union[None, Unset, datetime.datetime]:
             if data is None:
                 return data
@@ -114,13 +138,16 @@ class FormFieldDto:
                     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))
 
+
         def _parse_value(data: object) -> Union[None, Unset, str]:
             if data is None:
                 return data
@@ -130,13 +157,17 @@ class FormFieldDto:
 
         value = _parse_value(d.pop("value", UNSET))
 
+
         _type_ = d.pop("type", UNSET)
         type_: Union[Unset, FormFieldType]
-        if isinstance(_type_, Unset):
+        if isinstance(_type_,  Unset):
             type_ = UNSET
         else:
             type_ = check_form_field_type(_type_)
 
+
+
+
         form_field_dto = cls(
             key=key,
             value_string=value_string,
@@ -147,3 +178,4 @@ class FormFieldDto:
         )
 
         return form_field_dto
+

minikai/models/form_field_type.py

@@ -1,14 +1,8 @@
 from typing import Literal, cast
 
-FormFieldType = Literal["checkbox", "dateTime", "radio", "text"]
-
-FORM_FIELD_TYPE_VALUES: set[FormFieldType] = {
-    "checkbox",
-    "dateTime",
-    "radio",
-    "text",
-}
+FormFieldType = Literal['checkbox', 'dateTime', 'radio', 'text']
 
+FORM_FIELD_TYPE_VALUES: set[FormFieldType] = { 'checkbox', 'dateTime', 'radio', 'text',  }
 
 def check_form_field_type(value: str) -> FormFieldType:
     if value in FORM_FIELD_TYPE_VALUES: