daknode 0.1.0__py3-none-any.whl

daknode/models/message_out.py

@@ -0,0 +1,309 @@
+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 dateutil.parser import isoparse
+from typing import cast
+from typing import cast, Union
+from uuid import UUID
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="MessageOut")
+
+
+
+@_attrs_define
+class MessageOut:
+    """ `specs/18` §5.1.
+
+    `org_id`, `raw_s3_key`, `revision_id`, `event_id`, `deleted_at`,
+    `suppress_auto_reply` and `suppression_reason` are absent on purpose, each
+    for its own reason recorded in the spec. `risk_level`/`risk_signals` ARE
+    present: `architecture.md` §9 makes injection risk advisory metadata for
+    the developer's downstream agent, and withholding it defeats its purpose.
+
+        Attributes:
+            body_text (Union[None, str]):
+            channel (str):
+            created_at (datetime.datetime):
+            id (UUID):
+            in_reply_to (Union[None, str]):
+            inbox_id (UUID):
+            is_automated (bool):
+            is_bulk (bool):
+            list_id (Union[None, str]):
+            message_id_header (Union[None, str]):
+            recipient (str):
+            references_message_ids (Union[None, list[str]]):
+            risk_level (str):
+            risk_signals (Union[None, list[str]]):
+            sender (str):
+            sequence_number (int):
+            subject (Union[None, str]):
+            thread_id (UUID):
+     """
+
+    body_text: Union[None, str]
+    channel: str
+    created_at: datetime.datetime
+    id: UUID
+    in_reply_to: Union[None, str]
+    inbox_id: UUID
+    is_automated: bool
+    is_bulk: bool
+    list_id: Union[None, str]
+    message_id_header: Union[None, str]
+    recipient: str
+    references_message_ids: Union[None, list[str]]
+    risk_level: str
+    risk_signals: Union[None, list[str]]
+    sender: str
+    sequence_number: int
+    subject: Union[None, str]
+    thread_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        body_text: Union[None, str]
+        body_text = self.body_text
+
+        channel = self.channel
+
+        created_at = self.created_at.isoformat()
+
+        id = str(self.id)
+
+        in_reply_to: Union[None, str]
+        in_reply_to = self.in_reply_to
+
+        inbox_id = str(self.inbox_id)
+
+        is_automated = self.is_automated
+
+        is_bulk = self.is_bulk
+
+        list_id: Union[None, str]
+        list_id = self.list_id
+
+        message_id_header: Union[None, str]
+        message_id_header = self.message_id_header
+
+        recipient = self.recipient
+
+        references_message_ids: Union[None, list[str]]
+        if isinstance(self.references_message_ids, list):
+            references_message_ids = self.references_message_ids
+
+
+        else:
+            references_message_ids = self.references_message_ids
+
+        risk_level = self.risk_level
+
+        risk_signals: Union[None, list[str]]
+        if isinstance(self.risk_signals, list):
+            risk_signals = self.risk_signals
+
+
+        else:
+            risk_signals = self.risk_signals
+
+        sender = self.sender
+
+        sequence_number = self.sequence_number
+
+        subject: Union[None, str]
+        subject = self.subject
+
+        thread_id = str(self.thread_id)
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "body_text": body_text,
+            "channel": channel,
+            "created_at": created_at,
+            "id": id,
+            "in_reply_to": in_reply_to,
+            "inbox_id": inbox_id,
+            "is_automated": is_automated,
+            "is_bulk": is_bulk,
+            "list_id": list_id,
+            "message_id_header": message_id_header,
+            "recipient": recipient,
+            "references_message_ids": references_message_ids,
+            "risk_level": risk_level,
+            "risk_signals": risk_signals,
+            "sender": sender,
+            "sequence_number": sequence_number,
+            "subject": subject,
+            "thread_id": thread_id,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        def _parse_body_text(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        body_text = _parse_body_text(d.pop("body_text"))
+
+
+        channel = d.pop("channel")
+
+        created_at = isoparse(d.pop("created_at"))
+
+
+
+
+        id = UUID(d.pop("id"))
+
+
+
+
+        def _parse_in_reply_to(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        in_reply_to = _parse_in_reply_to(d.pop("in_reply_to"))
+
+
+        inbox_id = UUID(d.pop("inbox_id"))
+
+
+
+
+        is_automated = d.pop("is_automated")
+
+        is_bulk = d.pop("is_bulk")
+
+        def _parse_list_id(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        list_id = _parse_list_id(d.pop("list_id"))
+
+
+        def _parse_message_id_header(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        message_id_header = _parse_message_id_header(d.pop("message_id_header"))
+
+
+        recipient = d.pop("recipient")
+
+        def _parse_references_message_ids(data: object) -> Union[None, list[str]]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                references_message_ids_type_0 = cast(list[str], data)
+
+                return references_message_ids_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, list[str]], data)
+
+        references_message_ids = _parse_references_message_ids(d.pop("references_message_ids"))
+
+
+        risk_level = d.pop("risk_level")
+
+        def _parse_risk_signals(data: object) -> Union[None, list[str]]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, list):
+                    raise TypeError()
+                risk_signals_type_0 = cast(list[str], data)
+
+                return risk_signals_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, list[str]], data)
+
+        risk_signals = _parse_risk_signals(d.pop("risk_signals"))
+
+
+        sender = d.pop("sender")
+
+        sequence_number = d.pop("sequence_number")
+
+        def _parse_subject(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        subject = _parse_subject(d.pop("subject"))
+
+
+        thread_id = UUID(d.pop("thread_id"))
+
+
+
+
+        message_out = cls(
+            body_text=body_text,
+            channel=channel,
+            created_at=created_at,
+            id=id,
+            in_reply_to=in_reply_to,
+            inbox_id=inbox_id,
+            is_automated=is_automated,
+            is_bulk=is_bulk,
+            list_id=list_id,
+            message_id_header=message_id_header,
+            recipient=recipient,
+            references_message_ids=references_message_ids,
+            risk_level=risk_level,
+            risk_signals=risk_signals,
+            sender=sender,
+            sequence_number=sequence_number,
+            subject=subject,
+            thread_id=thread_id,
+        )
+
+
+        message_out.additional_properties = d
+        return message_out
+
+    @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

daknode/models/message_page.py

@@ -0,0 +1,116 @@
+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 typing import cast
+from typing import cast, Union
+
+if TYPE_CHECKING:
+  from ..models.message_out import MessageOut
+
+
+
+
+
+T = TypeVar("T", bound="MessagePage")
+
+
+
+@_attrs_define
+class MessagePage:
+    """
+        Attributes:
+            has_more (bool):
+            items (list['MessageOut']):
+            next_cursor (Union[None, str]):
+     """
+
+    has_more: bool
+    items: list['MessageOut']
+    next_cursor: Union[None, str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.message_out import MessageOut
+        has_more = self.has_more
+
+        items = []
+        for items_item_data in self.items:
+            items_item = items_item_data.to_dict()
+            items.append(items_item)
+
+
+
+        next_cursor: Union[None, str]
+        next_cursor = self.next_cursor
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "has_more": has_more,
+            "items": items,
+            "next_cursor": next_cursor,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.message_out import MessageOut
+        d = dict(src_dict)
+        has_more = d.pop("has_more")
+
+        items = []
+        _items = d.pop("items")
+        for items_item_data in (_items):
+            items_item = MessageOut.from_dict(items_item_data)
+
+
+
+            items.append(items_item)
+
+
+        def _parse_next_cursor(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+
+        message_page = cls(
+            has_more=has_more,
+            items=items,
+            next_cursor=next_cursor,
+        )
+
+
+        message_page.additional_properties = d
+        return message_page
+
+    @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

daknode/models/read_erasure_request_response_read_erasure_request.py

@@ -0,0 +1,63 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="ReadErasureRequestResponseReadErasureRequest")
+
+
+
+@_attrs_define
+class ReadErasureRequestResponseReadErasureRequest:
+    """
+     """
+
+    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)
+        read_erasure_request_response_read_erasure_request = cls(
+        )
+
+
+        read_erasure_request_response_read_erasure_request.additional_properties = d
+        return read_erasure_request_response_read_erasure_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

daknode/models/replay_response.py

@@ -0,0 +1,113 @@
+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 Union
+from uuid import UUID
+
+
+
+
+
+
+T = TypeVar("T", bound="ReplayResponse")
+
+
+
+@_attrs_define
+class ReplayResponse:
+    """
+        Attributes:
+            event_id (str):
+            outbox_id (UUID):
+            replay_count (int):
+            status (str):
+            event_id_preserved (Union[Unset, bool]):  Default: True.
+     """
+
+    event_id: str
+    outbox_id: UUID
+    replay_count: int
+    status: str
+    event_id_preserved: Union[Unset, bool] = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        event_id = self.event_id
+
+        outbox_id = str(self.outbox_id)
+
+        replay_count = self.replay_count
+
+        status = self.status
+
+        event_id_preserved = self.event_id_preserved
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "event_id": event_id,
+            "outbox_id": outbox_id,
+            "replay_count": replay_count,
+            "status": status,
+        })
+        if event_id_preserved is not UNSET:
+            field_dict["event_id_preserved"] = event_id_preserved
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        event_id = d.pop("event_id")
+
+        outbox_id = UUID(d.pop("outbox_id"))
+
+
+
+
+        replay_count = d.pop("replay_count")
+
+        status = d.pop("status")
+
+        event_id_preserved = d.pop("event_id_preserved", UNSET)
+
+        replay_response = cls(
+            event_id=event_id,
+            outbox_id=outbox_id,
+            replay_count=replay_count,
+            status=status,
+            event_id_preserved=event_id_preserved,
+        )
+
+
+        replay_response.additional_properties = d
+        return replay_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

daknode/models/revoke_request.py

@@ -0,0 +1,74 @@
+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
+
+
+
+
+
+
+
+T = TypeVar("T", bound="RevokeRequest")
+
+
+
+@_attrs_define
+class RevokeRequest:
+    """
+        Attributes:
+            recipient (str):
+     """
+
+    recipient: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        recipient = self.recipient
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "recipient": recipient,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        recipient = d.pop("recipient")
+
+        revoke_request = cls(
+            recipient=recipient,
+        )
+
+
+        revoke_request.additional_properties = d
+        return revoke_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