antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/text_content_part.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.text_content_part_type import TextContentPartType
+
+T = TypeVar("T", bound="TextContentPart")
+
+
+@_attrs_define
+class TextContentPart:
+    """Text content for multimodal input.
+
+    Attributes:
+        type_ (TextContentPartType):
+        text (str): Text content.
+    """
+
+    type_: TextContentPartType
+    text: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_.value
+
+        text = self.text
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "type": type_,
+                "text": text,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        type_ = TextContentPartType(d.pop("type"))
+
+        text = d.pop("text")
+
+        text_content_part = cls(
+            type_=type_,
+            text=text,
+        )
+
+        text_content_part.additional_properties = d
+        return text_content_part
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/text_content_part_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class TextContentPartType(str, Enum):
+    TEXT = "text"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/tool_call.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.tool_call_type import ToolCallType
+
+if TYPE_CHECKING:
+    from ..models.tool_call_function import ToolCallFunction
+
+
+T = TypeVar("T", bound="ToolCall")
+
+
+@_attrs_define
+class ToolCall:
+    """OpenAI-compatible assistant tool call.
+
+    Attributes:
+        id (str): Tool call identifier.
+        type_ (ToolCallType):
+        function (ToolCallFunction): The function called by a model tool call.
+    """
+
+    id: str
+    type_: ToolCallType
+    function: ToolCallFunction
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        type_ = self.type_.value
+
+        function = self.function.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "id": id,
+                "type": type_,
+                "function": function,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.tool_call_function import ToolCallFunction
+
+        d = dict(src_dict)
+        id = d.pop("id")
+
+        type_ = ToolCallType(d.pop("type"))
+
+        function = ToolCallFunction.from_dict(d.pop("function"))
+
+        tool_call = cls(
+            id=id,
+            type_=type_,
+            function=function,
+        )
+
+        tool_call.additional_properties = d
+        return tool_call
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/tool_call_function.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ToolCallFunction")
+
+
+@_attrs_define
+class ToolCallFunction:
+    """The function called by a model tool call.
+
+    Attributes:
+        name (str): Function name.
+        arguments (str): JSON string of function arguments.
+    """
+
+    name: str
+    arguments: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        arguments = self.arguments
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "arguments": arguments,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        arguments = d.pop("arguments")
+
+        tool_call_function = cls(
+            name=name,
+            arguments=arguments,
+        )
+
+        tool_call_function.additional_properties = d
+        return tool_call_function
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/tool_call_type.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class ToolCallType(str, Enum):
+    FUNCTION = "function"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/transaction_begin_request.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.sync_level import SyncLevel
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TransactionBeginRequest")
+
+
+@_attrs_define
+class TransactionBeginRequest:
+    """
+    Attributes:
+        sync_level (SyncLevel | Unset): Synchronization level for batch operations:
+            - "propose": Wait for Raft proposal acceptance (fastest, default)
+            - "write": Wait for Pebble KV write
+            - "full_text": Wait for full-text index WAL write
+            - "enrichments": Pre-compute enrichments before Raft proposal (synchronous enrichment generation)
+            - "aknn": Wait for vector index write with best-effort synchronous embedding (falls back to async on timeout,
+            slowest, most durable)
+            - "full_index": Wait for all index writes to complete (full-text + enrichments + aknn)
+    """
+
+    sync_level: SyncLevel | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        sync_level: str | Unset = UNSET
+        if not isinstance(self.sync_level, Unset):
+            sync_level = self.sync_level.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if sync_level is not UNSET:
+            field_dict["sync_level"] = sync_level
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        _sync_level = d.pop("sync_level", UNSET)
+        sync_level: SyncLevel | Unset
+        if isinstance(_sync_level, Unset):
+            sync_level = UNSET
+        else:
+            sync_level = SyncLevel(_sync_level)
+
+        transaction_begin_request = cls(
+            sync_level=sync_level,
+        )
+
+        transaction_begin_request.additional_properties = d
+        return transaction_begin_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/transaction_begin_response.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="TransactionBeginResponse")
+
+
+@_attrs_define
+class TransactionBeginResponse:
+    """
+    Attributes:
+        transaction_id (str):
+        begin_timestamp (int):
+        sync_level (str):
+    """
+
+    transaction_id: str
+    begin_timestamp: int
+    sync_level: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transaction_id = self.transaction_id
+
+        begin_timestamp = self.begin_timestamp
+
+        sync_level = self.sync_level
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transaction_id": transaction_id,
+                "begin_timestamp": begin_timestamp,
+                "sync_level": sync_level,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        transaction_id = d.pop("transaction_id")
+
+        begin_timestamp = d.pop("begin_timestamp")
+
+        sync_level = d.pop("sync_level")
+
+        transaction_begin_response = cls(
+            transaction_id=transaction_id,
+            begin_timestamp=begin_timestamp,
+            sync_level=sync_level,
+        )
+
+        transaction_begin_response.additional_properties = d
+        return transaction_begin_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/transaction_commit_request.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.sync_level import SyncLevel
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.transaction_commit_request_tables import TransactionCommitRequestTables
+    from ..models.transaction_read_item import TransactionReadItem
+
+
+T = TypeVar("T", bound="TransactionCommitRequest")
+
+
+@_attrs_define
+class TransactionCommitRequest:
+    """Stateless OCC (Optimistic Concurrency Control) transaction commit request.
+
+    The client reads documents (capturing version tokens from the X-Antfly-Version
+    response header on lookups), computes writes locally, then submits everything
+    in this single commit request. The server validates that all read versions
+    still match before executing writes atomically via 2PC.
+
+    **No server-side state**: There is no "begin" endpoint. The client manages
+    its own read set and submits the full transaction in one request.
+
+        Attributes:
+            read_set (list[TransactionReadItem]): Set of keys that were read during the transaction, with their observed
+                versions.
+                The server verifies these versions still match before committing writes.
+            tables (TransactionCommitRequestTables): Write set: map of table names to batch operations, same format as
+                MultiBatchRequest.tables.
+            sync_level (SyncLevel | Unset): Synchronization level for batch operations:
+                - "propose": Wait for Raft proposal acceptance (fastest, default)
+                - "write": Wait for Pebble KV write
+                - "full_text": Wait for full-text index WAL write
+                - "enrichments": Pre-compute enrichments before Raft proposal (synchronous enrichment generation)
+                - "aknn": Wait for vector index write with best-effort synchronous embedding (falls back to async on timeout,
+                slowest, most durable)
+                - "full_index": Wait for all index writes to complete (full-text + enrichments + aknn)
+    """
+
+    read_set: list[TransactionReadItem]
+    tables: TransactionCommitRequestTables
+    sync_level: SyncLevel | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        read_set = []
+        for read_set_item_data in self.read_set:
+            read_set_item = read_set_item_data.to_dict()
+            read_set.append(read_set_item)
+
+        tables = self.tables.to_dict()
+
+        sync_level: str | Unset = UNSET
+        if not isinstance(self.sync_level, Unset):
+            sync_level = self.sync_level.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "read_set": read_set,
+                "tables": tables,
+            }
+        )
+        if sync_level is not UNSET:
+            field_dict["sync_level"] = sync_level
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction_commit_request_tables import TransactionCommitRequestTables
+        from ..models.transaction_read_item import TransactionReadItem
+
+        d = dict(src_dict)
+        read_set = []
+        _read_set = d.pop("read_set")
+        for read_set_item_data in _read_set:
+            read_set_item = TransactionReadItem.from_dict(read_set_item_data)
+
+            read_set.append(read_set_item)
+
+        tables = TransactionCommitRequestTables.from_dict(d.pop("tables"))
+
+        _sync_level = d.pop("sync_level", UNSET)
+        sync_level: SyncLevel | Unset
+        if isinstance(_sync_level, Unset):
+            sync_level = UNSET
+        else:
+            sync_level = SyncLevel(_sync_level)
+
+        transaction_commit_request = cls(
+            read_set=read_set,
+            tables=tables,
+            sync_level=sync_level,
+        )
+
+        transaction_commit_request.additional_properties = d
+        return transaction_commit_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/transaction_commit_request_tables.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.batch_request import BatchRequest
+
+
+T = TypeVar("T", bound="TransactionCommitRequestTables")
+
+
+@_attrs_define
+class TransactionCommitRequestTables:
+    """Write set: map of table names to batch operations, same format as MultiBatchRequest.tables."""
+
+    additional_properties: dict[str, BatchRequest] = _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.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.batch_request import BatchRequest
+
+        d = dict(src_dict)
+        transaction_commit_request_tables = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = BatchRequest.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        transaction_commit_request_tables.additional_properties = additional_properties
+        return transaction_commit_request_tables
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> BatchRequest:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: BatchRequest) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/transaction_commit_response.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.transaction_commit_response_status import TransactionCommitResponseStatus
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.transaction_commit_response_conflict import TransactionCommitResponseConflict
+    from ..models.transaction_commit_response_tables import TransactionCommitResponseTables
+
+
+T = TypeVar("T", bound="TransactionCommitResponse")
+
+
+@_attrs_define
+class TransactionCommitResponse:
+    """Result of an OCC transaction commit attempt.
+
+    Attributes:
+        status (TransactionCommitResponseStatus): Whether the transaction was committed or aborted due to a conflict
+        conflict (TransactionCommitResponseConflict | Unset): Details about the conflict that caused an abort (only
+            present when status is "aborted")
+        tables (TransactionCommitResponseTables | Unset): Per-table batch results (only present when status is
+            "committed")
+    """
+
+    status: TransactionCommitResponseStatus
+    conflict: TransactionCommitResponseConflict | Unset = UNSET
+    tables: TransactionCommitResponseTables | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        status = self.status.value
+
+        conflict: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.conflict, Unset):
+            conflict = self.conflict.to_dict()
+
+        tables: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.tables, Unset):
+            tables = self.tables.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "status": status,
+            }
+        )
+        if conflict is not UNSET:
+            field_dict["conflict"] = conflict
+        if tables is not UNSET:
+            field_dict["tables"] = tables
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction_commit_response_conflict import TransactionCommitResponseConflict
+        from ..models.transaction_commit_response_tables import TransactionCommitResponseTables
+
+        d = dict(src_dict)
+        status = TransactionCommitResponseStatus(d.pop("status"))
+
+        _conflict = d.pop("conflict", UNSET)
+        conflict: TransactionCommitResponseConflict | Unset
+        if isinstance(_conflict, Unset):
+            conflict = UNSET
+        else:
+            conflict = TransactionCommitResponseConflict.from_dict(_conflict)
+
+        _tables = d.pop("tables", UNSET)
+        tables: TransactionCommitResponseTables | Unset
+        if isinstance(_tables, Unset):
+            tables = UNSET
+        else:
+            tables = TransactionCommitResponseTables.from_dict(_tables)
+
+        transaction_commit_response = cls(
+            status=status,
+            conflict=conflict,
+            tables=tables,
+        )
+
+        transaction_commit_response.additional_properties = d
+        return transaction_commit_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties