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

antfly/client_generated/models/transaction_session_details_response.py

@@ -0,0 +1,268 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.transaction_session_read_snapshot import TransactionSessionReadSnapshot
+    from ..models.transaction_session_table_detail import TransactionSessionTableDetail
+
+
+T = TypeVar("T", bound="TransactionSessionDetailsResponse")
+
+
+@_attrs_define
+class TransactionSessionDetailsResponse:
+    """
+    Attributes:
+        transaction_id (str):
+        owner_node_id (int):
+        begin_timestamp (int):
+        last_touched_timestamp (int):
+        lease_expires_at (int):
+        lease_state (str):
+        sync_level (str):
+        staged_table_count (int):
+        staged_read_count (int):
+        staged_write_count (int):
+        staged_delete_count (int):
+        read_snapshot_count (int):
+        savepoint_count (int):
+        durable (bool):
+        savepoint_limit (int | None | Unset):
+        remaining_savepoints (int | None | Unset):
+        tables (list[TransactionSessionTableDetail] | Unset):
+        read_snapshots (list[TransactionSessionReadSnapshot] | Unset):
+        savepoint_ids (list[int] | Unset):
+    """
+
+    transaction_id: str
+    owner_node_id: int
+    begin_timestamp: int
+    last_touched_timestamp: int
+    lease_expires_at: int
+    lease_state: str
+    sync_level: str
+    staged_table_count: int
+    staged_read_count: int
+    staged_write_count: int
+    staged_delete_count: int
+    read_snapshot_count: int
+    savepoint_count: int
+    durable: bool
+    savepoint_limit: int | None | Unset = UNSET
+    remaining_savepoints: int | None | Unset = UNSET
+    tables: list[TransactionSessionTableDetail] | Unset = UNSET
+    read_snapshots: list[TransactionSessionReadSnapshot] | Unset = UNSET
+    savepoint_ids: list[int] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transaction_id = self.transaction_id
+
+        owner_node_id = self.owner_node_id
+
+        begin_timestamp = self.begin_timestamp
+
+        last_touched_timestamp = self.last_touched_timestamp
+
+        lease_expires_at = self.lease_expires_at
+
+        lease_state = self.lease_state
+
+        sync_level = self.sync_level
+
+        staged_table_count = self.staged_table_count
+
+        staged_read_count = self.staged_read_count
+
+        staged_write_count = self.staged_write_count
+
+        staged_delete_count = self.staged_delete_count
+
+        read_snapshot_count = self.read_snapshot_count
+
+        savepoint_count = self.savepoint_count
+
+        durable = self.durable
+
+        savepoint_limit: int | None | Unset
+        if isinstance(self.savepoint_limit, Unset):
+            savepoint_limit = UNSET
+        else:
+            savepoint_limit = self.savepoint_limit
+
+        remaining_savepoints: int | None | Unset
+        if isinstance(self.remaining_savepoints, Unset):
+            remaining_savepoints = UNSET
+        else:
+            remaining_savepoints = self.remaining_savepoints
+
+        tables: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.tables, Unset):
+            tables = []
+            for tables_item_data in self.tables:
+                tables_item = tables_item_data.to_dict()
+                tables.append(tables_item)
+
+        read_snapshots: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.read_snapshots, Unset):
+            read_snapshots = []
+            for read_snapshots_item_data in self.read_snapshots:
+                read_snapshots_item = read_snapshots_item_data.to_dict()
+                read_snapshots.append(read_snapshots_item)
+
+        savepoint_ids: list[int] | Unset = UNSET
+        if not isinstance(self.savepoint_ids, Unset):
+            savepoint_ids = self.savepoint_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transaction_id": transaction_id,
+                "owner_node_id": owner_node_id,
+                "begin_timestamp": begin_timestamp,
+                "last_touched_timestamp": last_touched_timestamp,
+                "lease_expires_at": lease_expires_at,
+                "lease_state": lease_state,
+                "sync_level": sync_level,
+                "staged_table_count": staged_table_count,
+                "staged_read_count": staged_read_count,
+                "staged_write_count": staged_write_count,
+                "staged_delete_count": staged_delete_count,
+                "read_snapshot_count": read_snapshot_count,
+                "savepoint_count": savepoint_count,
+                "durable": durable,
+            }
+        )
+        if savepoint_limit is not UNSET:
+            field_dict["savepoint_limit"] = savepoint_limit
+        if remaining_savepoints is not UNSET:
+            field_dict["remaining_savepoints"] = remaining_savepoints
+        if tables is not UNSET:
+            field_dict["tables"] = tables
+        if read_snapshots is not UNSET:
+            field_dict["read_snapshots"] = read_snapshots
+        if savepoint_ids is not UNSET:
+            field_dict["savepoint_ids"] = savepoint_ids
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction_session_read_snapshot import TransactionSessionReadSnapshot
+        from ..models.transaction_session_table_detail import TransactionSessionTableDetail
+
+        d = dict(src_dict)
+        transaction_id = d.pop("transaction_id")
+
+        owner_node_id = d.pop("owner_node_id")
+
+        begin_timestamp = d.pop("begin_timestamp")
+
+        last_touched_timestamp = d.pop("last_touched_timestamp")
+
+        lease_expires_at = d.pop("lease_expires_at")
+
+        lease_state = d.pop("lease_state")
+
+        sync_level = d.pop("sync_level")
+
+        staged_table_count = d.pop("staged_table_count")
+
+        staged_read_count = d.pop("staged_read_count")
+
+        staged_write_count = d.pop("staged_write_count")
+
+        staged_delete_count = d.pop("staged_delete_count")
+
+        read_snapshot_count = d.pop("read_snapshot_count")
+
+        savepoint_count = d.pop("savepoint_count")
+
+        durable = d.pop("durable")
+
+        def _parse_savepoint_limit(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        savepoint_limit = _parse_savepoint_limit(d.pop("savepoint_limit", UNSET))
+
+        def _parse_remaining_savepoints(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        remaining_savepoints = _parse_remaining_savepoints(d.pop("remaining_savepoints", UNSET))
+
+        _tables = d.pop("tables", UNSET)
+        tables: list[TransactionSessionTableDetail] | Unset = UNSET
+        if _tables is not UNSET:
+            tables = []
+            for tables_item_data in _tables:
+                tables_item = TransactionSessionTableDetail.from_dict(tables_item_data)
+
+                tables.append(tables_item)
+
+        _read_snapshots = d.pop("read_snapshots", UNSET)
+        read_snapshots: list[TransactionSessionReadSnapshot] | Unset = UNSET
+        if _read_snapshots is not UNSET:
+            read_snapshots = []
+            for read_snapshots_item_data in _read_snapshots:
+                read_snapshots_item = TransactionSessionReadSnapshot.from_dict(read_snapshots_item_data)
+
+                read_snapshots.append(read_snapshots_item)
+
+        savepoint_ids = cast(list[int], d.pop("savepoint_ids", UNSET))
+
+        transaction_session_details_response = cls(
+            transaction_id=transaction_id,
+            owner_node_id=owner_node_id,
+            begin_timestamp=begin_timestamp,
+            last_touched_timestamp=last_touched_timestamp,
+            lease_expires_at=lease_expires_at,
+            lease_state=lease_state,
+            sync_level=sync_level,
+            staged_table_count=staged_table_count,
+            staged_read_count=staged_read_count,
+            staged_write_count=staged_write_count,
+            staged_delete_count=staged_delete_count,
+            read_snapshot_count=read_snapshot_count,
+            savepoint_count=savepoint_count,
+            durable=durable,
+            savepoint_limit=savepoint_limit,
+            remaining_savepoints=remaining_savepoints,
+            tables=tables,
+            read_snapshots=read_snapshots,
+            savepoint_ids=savepoint_ids,
+        )
+
+        transaction_session_details_response.additional_properties = d
+        return transaction_session_details_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_session_list_response.py

@@ -0,0 +1,106 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.transaction_session_status import TransactionSessionStatus
+
+
+T = TypeVar("T", bound="TransactionSessionListResponse")
+
+
+@_attrs_define
+class TransactionSessionListResponse:
+    """
+    Attributes:
+        session_count (int | Unset):
+        lease_held_count (int | Unset):
+        lease_expired_count (int | Unset):
+        sessions (list[TransactionSessionStatus] | Unset):
+    """
+
+    session_count: int | Unset = UNSET
+    lease_held_count: int | Unset = UNSET
+    lease_expired_count: int | Unset = UNSET
+    sessions: list[TransactionSessionStatus] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        session_count = self.session_count
+
+        lease_held_count = self.lease_held_count
+
+        lease_expired_count = self.lease_expired_count
+
+        sessions: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.sessions, Unset):
+            sessions = []
+            for sessions_item_data in self.sessions:
+                sessions_item = sessions_item_data.to_dict()
+                sessions.append(sessions_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if session_count is not UNSET:
+            field_dict["session_count"] = session_count
+        if lease_held_count is not UNSET:
+            field_dict["lease_held_count"] = lease_held_count
+        if lease_expired_count is not UNSET:
+            field_dict["lease_expired_count"] = lease_expired_count
+        if sessions is not UNSET:
+            field_dict["sessions"] = sessions
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.transaction_session_status import TransactionSessionStatus
+
+        d = dict(src_dict)
+        session_count = d.pop("session_count", UNSET)
+
+        lease_held_count = d.pop("lease_held_count", UNSET)
+
+        lease_expired_count = d.pop("lease_expired_count", UNSET)
+
+        _sessions = d.pop("sessions", UNSET)
+        sessions: list[TransactionSessionStatus] | Unset = UNSET
+        if _sessions is not UNSET:
+            sessions = []
+            for sessions_item_data in _sessions:
+                sessions_item = TransactionSessionStatus.from_dict(sessions_item_data)
+
+                sessions.append(sessions_item)
+
+        transaction_session_list_response = cls(
+            session_count=session_count,
+            lease_held_count=lease_held_count,
+            lease_expired_count=lease_expired_count,
+            sessions=sessions,
+        )
+
+        transaction_session_list_response.additional_properties = d
+        return transaction_session_list_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_session_read_snapshot.py

@@ -0,0 +1,88 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TransactionSessionReadSnapshot")
+
+
+@_attrs_define
+class TransactionSessionReadSnapshot:
+    """
+    Attributes:
+        table (str | Unset):
+        key (str | Unset):
+        version (int | Unset):
+        document (Any | Unset):
+    """
+
+    table: str | Unset = UNSET
+    key: str | Unset = UNSET
+    version: int | Unset = UNSET
+    document: Any | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        table = self.table
+
+        key = self.key
+
+        version = self.version
+
+        document = self.document
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if table is not UNSET:
+            field_dict["table"] = table
+        if key is not UNSET:
+            field_dict["key"] = key
+        if version is not UNSET:
+            field_dict["version"] = version
+        if document is not UNSET:
+            field_dict["document"] = document
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        table = d.pop("table", UNSET)
+
+        key = d.pop("key", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        document = d.pop("document", UNSET)
+
+        transaction_session_read_snapshot = cls(
+            table=table,
+            key=key,
+            version=version,
+            document=document,
+        )
+
+        transaction_session_read_snapshot.additional_properties = d
+        return transaction_session_read_snapshot
+
+    @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_session_status.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="TransactionSessionStatus")
+
+
+@_attrs_define
+class TransactionSessionStatus:
+    """
+    Attributes:
+        transaction_id (str):
+        owner_node_id (int):
+        begin_timestamp (int):
+        last_touched_timestamp (int):
+        lease_expires_at (int):
+        lease_state (str):
+        sync_level (str):
+        staged_table_count (int):
+        staged_read_count (int):
+        staged_write_count (int):
+        staged_delete_count (int):
+        read_snapshot_count (int):
+        savepoint_count (int):
+        durable (bool):
+        savepoint_limit (int | None | Unset):
+        remaining_savepoints (int | None | Unset):
+    """
+
+    transaction_id: str
+    owner_node_id: int
+    begin_timestamp: int
+    last_touched_timestamp: int
+    lease_expires_at: int
+    lease_state: str
+    sync_level: str
+    staged_table_count: int
+    staged_read_count: int
+    staged_write_count: int
+    staged_delete_count: int
+    read_snapshot_count: int
+    savepoint_count: int
+    durable: bool
+    savepoint_limit: int | None | Unset = UNSET
+    remaining_savepoints: int | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transaction_id = self.transaction_id
+
+        owner_node_id = self.owner_node_id
+
+        begin_timestamp = self.begin_timestamp
+
+        last_touched_timestamp = self.last_touched_timestamp
+
+        lease_expires_at = self.lease_expires_at
+
+        lease_state = self.lease_state
+
+        sync_level = self.sync_level
+
+        staged_table_count = self.staged_table_count
+
+        staged_read_count = self.staged_read_count
+
+        staged_write_count = self.staged_write_count
+
+        staged_delete_count = self.staged_delete_count
+
+        read_snapshot_count = self.read_snapshot_count
+
+        savepoint_count = self.savepoint_count
+
+        durable = self.durable
+
+        savepoint_limit: int | None | Unset
+        if isinstance(self.savepoint_limit, Unset):
+            savepoint_limit = UNSET
+        else:
+            savepoint_limit = self.savepoint_limit
+
+        remaining_savepoints: int | None | Unset
+        if isinstance(self.remaining_savepoints, Unset):
+            remaining_savepoints = UNSET
+        else:
+            remaining_savepoints = self.remaining_savepoints
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transaction_id": transaction_id,
+                "owner_node_id": owner_node_id,
+                "begin_timestamp": begin_timestamp,
+                "last_touched_timestamp": last_touched_timestamp,
+                "lease_expires_at": lease_expires_at,
+                "lease_state": lease_state,
+                "sync_level": sync_level,
+                "staged_table_count": staged_table_count,
+                "staged_read_count": staged_read_count,
+                "staged_write_count": staged_write_count,
+                "staged_delete_count": staged_delete_count,
+                "read_snapshot_count": read_snapshot_count,
+                "savepoint_count": savepoint_count,
+                "durable": durable,
+            }
+        )
+        if savepoint_limit is not UNSET:
+            field_dict["savepoint_limit"] = savepoint_limit
+        if remaining_savepoints is not UNSET:
+            field_dict["remaining_savepoints"] = remaining_savepoints
+
+        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")
+
+        owner_node_id = d.pop("owner_node_id")
+
+        begin_timestamp = d.pop("begin_timestamp")
+
+        last_touched_timestamp = d.pop("last_touched_timestamp")
+
+        lease_expires_at = d.pop("lease_expires_at")
+
+        lease_state = d.pop("lease_state")
+
+        sync_level = d.pop("sync_level")
+
+        staged_table_count = d.pop("staged_table_count")
+
+        staged_read_count = d.pop("staged_read_count")
+
+        staged_write_count = d.pop("staged_write_count")
+
+        staged_delete_count = d.pop("staged_delete_count")
+
+        read_snapshot_count = d.pop("read_snapshot_count")
+
+        savepoint_count = d.pop("savepoint_count")
+
+        durable = d.pop("durable")
+
+        def _parse_savepoint_limit(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        savepoint_limit = _parse_savepoint_limit(d.pop("savepoint_limit", UNSET))
+
+        def _parse_remaining_savepoints(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        remaining_savepoints = _parse_remaining_savepoints(d.pop("remaining_savepoints", UNSET))
+
+        transaction_session_status = cls(
+            transaction_id=transaction_id,
+            owner_node_id=owner_node_id,
+            begin_timestamp=begin_timestamp,
+            last_touched_timestamp=last_touched_timestamp,
+            lease_expires_at=lease_expires_at,
+            lease_state=lease_state,
+            sync_level=sync_level,
+            staged_table_count=staged_table_count,
+            staged_read_count=staged_read_count,
+            staged_write_count=staged_write_count,
+            staged_delete_count=staged_delete_count,
+            read_snapshot_count=read_snapshot_count,
+            savepoint_count=savepoint_count,
+            durable=durable,
+            savepoint_limit=savepoint_limit,
+            remaining_savepoints=remaining_savepoints,
+        )
+
+        transaction_session_status.additional_properties = d
+        return transaction_session_status
+
+    @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