holder-python 0.2.5__py3-none-any.whl

holder/generated/models/card_history_page_data.py

@@ -0,0 +1,114 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_history_entry import CardHistoryEntry
+
+
+T = TypeVar("T", bound="CardHistoryPageData")
+
+
+@_attrs_define
+class CardHistoryPageData:
+    """
+    Attributes:
+        head_oid (None | str):
+        entries (list[CardHistoryEntry]):
+        next_cursor (None | str):
+        scan_limited (bool): True when History examined its bounded number of revisions before reaching the end;
+            next_cursor continues the scan.
+    """
+
+    head_oid: None | str
+    entries: list[CardHistoryEntry]
+    next_cursor: None | str
+    scan_limited: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        head_oid: None | str
+        head_oid = self.head_oid
+
+        entries = []
+        for entries_item_data in self.entries:
+            entries_item = entries_item_data.to_dict()
+            entries.append(entries_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        scan_limited = self.scan_limited
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "head_oid": head_oid,
+                "entries": entries,
+                "next_cursor": next_cursor,
+                "scan_limited": scan_limited,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_entry import CardHistoryEntry
+
+        d = dict(src_dict)
+
+        def _parse_head_oid(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        head_oid = _parse_head_oid(d.pop("head_oid"))
+
+        entries = []
+        _entries = d.pop("entries")
+        for entries_item_data in _entries:
+            entries_item = CardHistoryEntry.from_dict(entries_item_data)
+
+            entries.append(entries_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        scan_limited = d.pop("scan_limited")
+
+        card_history_page_data = cls(
+            head_oid=head_oid,
+            entries=entries,
+            next_cursor=next_cursor,
+            scan_limited=scan_limited,
+        )
+
+        card_history_page_data.additional_properties = d
+        return card_history_page_data
+
+    @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

holder/generated/models/card_history_page_response.py

@@ -0,0 +1,76 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_history_page_data import CardHistoryPageData
+
+
+T = TypeVar("T", bound="CardHistoryPageResponse")
+
+
+@_attrs_define
+class CardHistoryPageResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardHistoryPageData):
+    """
+
+    ok: bool
+    data: CardHistoryPageData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_page_data import CardHistoryPageData
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardHistoryPageData.from_dict(d.pop("data"))
+
+        card_history_page_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_history_page_response.additional_properties = d
+        return card_history_page_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

holder/generated/models/card_history_restore_response.py

@@ -0,0 +1,80 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_history_restore_response_data import (
+        CardHistoryRestoreResponseData,
+    )
+
+
+T = TypeVar("T", bound="CardHistoryRestoreResponse")
+
+
+@_attrs_define
+class CardHistoryRestoreResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardHistoryRestoreResponseData):
+    """
+
+    ok: bool
+    data: CardHistoryRestoreResponseData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_restore_response_data import (
+            CardHistoryRestoreResponseData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardHistoryRestoreResponseData.from_dict(d.pop("data"))
+
+        card_history_restore_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_history_restore_response.additional_properties = d
+        return card_history_restore_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

holder/generated/models/card_history_restore_response_data.py

@@ -0,0 +1,108 @@
+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 typing_extensions import Self
+
+T = TypeVar("T", bound="CardHistoryRestoreResponseData")
+
+
+@_attrs_define
+class CardHistoryRestoreResponseData:
+    """
+    Attributes:
+        card_id (str):
+        restored_from_oid (str): Canonical full commit object ID of the selected historical snapshot.
+        result_oid (str): Canonical full commit object ID created by the restoration.
+        title (str):
+        updated_at (int):
+        deleted_at (int | None):
+    """
+
+    card_id: str
+    restored_from_oid: str
+    result_oid: str
+    title: str
+    updated_at: int
+    deleted_at: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        card_id = self.card_id
+
+        restored_from_oid = self.restored_from_oid
+
+        result_oid = self.result_oid
+
+        title = self.title
+
+        updated_at = self.updated_at
+
+        deleted_at: int | None
+        deleted_at = self.deleted_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "card_id": card_id,
+                "restored_from_oid": restored_from_oid,
+                "result_oid": result_oid,
+                "title": title,
+                "updated_at": updated_at,
+                "deleted_at": deleted_at,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        card_id = d.pop("card_id")
+
+        restored_from_oid = d.pop("restored_from_oid")
+
+        result_oid = d.pop("result_oid")
+
+        title = d.pop("title")
+
+        updated_at = d.pop("updated_at")
+
+        def _parse_deleted_at(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        deleted_at = _parse_deleted_at(d.pop("deleted_at"))
+
+        card_history_restore_response_data = cls(
+            card_id=card_id,
+            restored_from_oid=restored_from_oid,
+            result_oid=result_oid,
+            title=title,
+            updated_at=updated_at,
+            deleted_at=deleted_at,
+        )
+
+        card_history_restore_response_data.additional_properties = d
+        return card_history_restore_response_data
+
+    @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

holder/generated/models/card_history_snapshot_response.py

@@ -0,0 +1,80 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_history_snapshot_response_data import (
+        CardHistorySnapshotResponseData,
+    )
+
+
+T = TypeVar("T", bound="CardHistorySnapshotResponse")
+
+
+@_attrs_define
+class CardHistorySnapshotResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardHistorySnapshotResponseData):
+    """
+
+    ok: bool
+    data: CardHistorySnapshotResponseData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_snapshot_response_data import (
+            CardHistorySnapshotResponseData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardHistorySnapshotResponseData.from_dict(d.pop("data"))
+
+        card_history_snapshot_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_history_snapshot_response.additional_properties = d
+        return card_history_snapshot_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

holder/generated/models/card_history_snapshot_response_data.py

@@ -0,0 +1,76 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.card_history_version import CardHistoryVersion
+
+
+T = TypeVar("T", bound="CardHistorySnapshotResponseData")
+
+
+@_attrs_define
+class CardHistorySnapshotResponseData:
+    """
+    Attributes:
+        card_id (str):
+        snapshot (CardHistoryVersion):
+    """
+
+    card_id: str
+    snapshot: CardHistoryVersion
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        card_id = self.card_id
+
+        snapshot = self.snapshot.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "card_id": card_id,
+                "snapshot": snapshot,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_version import CardHistoryVersion
+
+        d = dict(src_dict)
+        card_id = d.pop("card_id")
+
+        snapshot = CardHistoryVersion.from_dict(d.pop("snapshot"))
+
+        card_history_snapshot_response_data = cls(
+            card_id=card_id,
+            snapshot=snapshot,
+        )
+
+        card_history_snapshot_response_data.additional_properties = d
+        return card_history_snapshot_response_data
+
+    @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

holder/generated/models/card_history_version.py

@@ -0,0 +1,86 @@
+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 typing_extensions import Self
+
+T = TypeVar("T", bound="CardHistoryVersion")
+
+
+@_attrs_define
+class CardHistoryVersion:
+    """
+    Attributes:
+        exists (bool):
+        oid (str):
+        title (str):
+        body (str):
+    """
+
+    exists: bool
+    oid: str
+    title: str
+    body: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        exists = self.exists
+
+        oid = self.oid
+
+        title = self.title
+
+        body = self.body
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "exists": exists,
+                "oid": oid,
+                "title": title,
+                "body": body,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        exists = d.pop("exists")
+
+        oid = d.pop("oid")
+
+        title = d.pop("title")
+
+        body = d.pop("body")
+
+        card_history_version = cls(
+            exists=exists,
+            oid=oid,
+            title=title,
+            body=body,
+        )
+
+        card_history_version.additional_properties = d
+        return card_history_version
+
+    @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