daknode 0.1.0__py3-none-any.whl

daknode/models/erasure_request_body.py

@@ -0,0 +1,60 @@
+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="ErasureRequestBody")
+
+
+
+@_attrs_define
+class ErasureRequestBody:
+    """ The address is in the BODY, never the path or a query parameter.
+
+    A URL is written to every proxy, load balancer and access log on the path
+    and leaks through `Referer`. Putting a data subject's address there would
+    scatter it across systems this erasure cannot reach.
+
+        Attributes:
+            subject_email (str):
+     """
+
+    subject_email: str
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        subject_email = self.subject_email
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "subject_email": subject_email,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        subject_email = d.pop("subject_email")
+
+        erasure_request_body = cls(
+            subject_email=subject_email,
+        )
+
+        return erasure_request_body

daknode/models/http_validation_error.py

@@ -0,0 +1,97 @@
+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 Union
+
+if TYPE_CHECKING:
+  from ..models.validation_error import ValidationError
+
+
+
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+
+@_attrs_define
+class HTTPValidationError:
+    """
+        Attributes:
+            detail (Union[Unset, list['ValidationError']]):
+     """
+
+    detail: Union[Unset, list['ValidationError']] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.validation_error import ValidationError
+        detail: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+        })
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+        d = dict(src_dict)
+        detail = []
+        _detail = d.pop("detail", UNSET)
+        for detail_item_data in (_detail or []):
+            detail_item = ValidationError.from_dict(detail_item_data)
+
+
+
+            detail.append(detail_item)
+
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @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/inbox_create_request.py

@@ -0,0 +1,120 @@
+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, Union
+from typing import Union
+
+
+
+
+
+
+T = TypeVar("T", bound="InboxCreateRequest")
+
+
+
+@_attrs_define
+class InboxCreateRequest:
+    """
+        Attributes:
+            alias (str): Local part of the address, e.g. 'support' for support@…
+            display_name (Union[None, Unset, str]):
+            webhook_url (Union[None, Unset, str]): HTTPS destination for inbound message events. Validated against the
+                egress policy before it is stored.
+     """
+
+    alias: str
+    display_name: Union[None, Unset, str] = UNSET
+    webhook_url: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        alias = self.alias
+
+        display_name: Union[None, Unset, str]
+        if isinstance(self.display_name, Unset):
+            display_name = UNSET
+        else:
+            display_name = self.display_name
+
+        webhook_url: Union[None, Unset, str]
+        if isinstance(self.webhook_url, Unset):
+            webhook_url = UNSET
+        else:
+            webhook_url = self.webhook_url
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "alias": alias,
+        })
+        if display_name is not UNSET:
+            field_dict["display_name"] = display_name
+        if webhook_url is not UNSET:
+            field_dict["webhook_url"] = webhook_url
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        alias = d.pop("alias")
+
+        def _parse_display_name(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)
+
+        display_name = _parse_display_name(d.pop("display_name", UNSET))
+
+
+        def _parse_webhook_url(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)
+
+        webhook_url = _parse_webhook_url(d.pop("webhook_url", UNSET))
+
+
+        inbox_create_request = cls(
+            alias=alias,
+            display_name=display_name,
+            webhook_url=webhook_url,
+        )
+
+
+        inbox_create_request.additional_properties = d
+        return inbox_create_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/inbox_response.py

@@ -0,0 +1,148 @@
+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, Union
+from typing import Union
+from uuid import UUID
+
+
+
+
+
+
+T = TypeVar("T", bound="InboxResponse")
+
+
+
+@_attrs_define
+class InboxResponse:
+    """
+        Attributes:
+            address (str):
+            channel (str):
+            display_name (Union[None, str]):
+            inbox_id (UUID):
+            webhook_url (Union[None, str]):
+            webhook_secret (Union[None, Unset, str]):
+     """
+
+    address: str
+    channel: str
+    display_name: Union[None, str]
+    inbox_id: UUID
+    webhook_url: Union[None, str]
+    webhook_secret: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        address = self.address
+
+        channel = self.channel
+
+        display_name: Union[None, str]
+        display_name = self.display_name
+
+        inbox_id = str(self.inbox_id)
+
+        webhook_url: Union[None, str]
+        webhook_url = self.webhook_url
+
+        webhook_secret: Union[None, Unset, str]
+        if isinstance(self.webhook_secret, Unset):
+            webhook_secret = UNSET
+        else:
+            webhook_secret = self.webhook_secret
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "address": address,
+            "channel": channel,
+            "display_name": display_name,
+            "inbox_id": inbox_id,
+            "webhook_url": webhook_url,
+        })
+        if webhook_secret is not UNSET:
+            field_dict["webhook_secret"] = webhook_secret
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        address = d.pop("address")
+
+        channel = d.pop("channel")
+
+        def _parse_display_name(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        display_name = _parse_display_name(d.pop("display_name"))
+
+
+        inbox_id = UUID(d.pop("inbox_id"))
+
+
+
+
+        def _parse_webhook_url(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        webhook_url = _parse_webhook_url(d.pop("webhook_url"))
+
+
+        def _parse_webhook_secret(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)
+
+        webhook_secret = _parse_webhook_secret(d.pop("webhook_secret", UNSET))
+
+
+        inbox_response = cls(
+            address=address,
+            channel=channel,
+            display_name=display_name,
+            inbox_id=inbox_id,
+            webhook_url=webhook_url,
+            webhook_secret=webhook_secret,
+        )
+
+
+        inbox_response.additional_properties = d
+        return inbox_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