daknode 0.1.0__py3-none-any.whl

daknode/models/block_rule_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.block_rule_out import BlockRuleOut
+
+
+
+
+
+T = TypeVar("T", bound="BlockRulePage")
+
+
+
+@_attrs_define
+class BlockRulePage:
+    """
+        Attributes:
+            has_more (bool):
+            items (list['BlockRuleOut']):
+            next_cursor (Union[None, str]):
+     """
+
+    has_more: bool
+    items: list['BlockRuleOut']
+    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.block_rule_out import BlockRuleOut
+        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.block_rule_out import BlockRuleOut
+        d = dict(src_dict)
+        has_more = d.pop("has_more")
+
+        items = []
+        _items = d.pop("items")
+        for items_item_data in (_items):
+            items_item = BlockRuleOut.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"))
+
+
+        block_rule_page = cls(
+            has_more=has_more,
+            items=items,
+            next_cursor=next_cursor,
+        )
+
+
+        block_rule_page.additional_properties = d
+        return block_rule_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/consent_request.py

@@ -0,0 +1,104 @@
+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
+import datetime
+
+
+
+
+
+
+T = TypeVar("T", bound="ConsentRequest")
+
+
+
+@_attrs_define
+class ConsentRequest:
+    """
+        Attributes:
+            collected_at (datetime.datetime): When consent was collected. Must be in the past.
+            evidence_ref (str): Form URL, contract id or import batch identifying the evidence retained for this consent.
+            recipient (str):
+            source (str): One of: api_signup, contract, offline_import, web_form
+     """
+
+    collected_at: datetime.datetime
+    evidence_ref: str
+    recipient: str
+    source: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        collected_at = self.collected_at.isoformat()
+
+        evidence_ref = self.evidence_ref
+
+        recipient = self.recipient
+
+        source = self.source
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "collected_at": collected_at,
+            "evidence_ref": evidence_ref,
+            "recipient": recipient,
+            "source": source,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        collected_at = isoparse(d.pop("collected_at"))
+
+
+
+
+        evidence_ref = d.pop("evidence_ref")
+
+        recipient = d.pop("recipient")
+
+        source = d.pop("source")
+
+        consent_request = cls(
+            collected_at=collected_at,
+            evidence_ref=evidence_ref,
+            recipient=recipient,
+            source=source,
+        )
+
+
+        consent_request.additional_properties = d
+        return consent_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/consent_response.py

@@ -0,0 +1,105 @@
+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="ConsentResponse")
+
+
+
+@_attrs_define
+class ConsentResponse:
+    """
+        Attributes:
+            consent_id (UUID):
+            recipient (str):
+            source (str):
+            basis (Union[Unset, str]):  Default: 'tenant_declared'.
+     """
+
+    consent_id: UUID
+    recipient: str
+    source: str
+    basis: Union[Unset, str] = 'tenant_declared'
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        consent_id = str(self.consent_id)
+
+        recipient = self.recipient
+
+        source = self.source
+
+        basis = self.basis
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "consent_id": consent_id,
+            "recipient": recipient,
+            "source": source,
+        })
+        if basis is not UNSET:
+            field_dict["basis"] = basis
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        consent_id = UUID(d.pop("consent_id"))
+
+
+
+
+        recipient = d.pop("recipient")
+
+        source = d.pop("source")
+
+        basis = d.pop("basis", UNSET)
+
+        consent_response = cls(
+            consent_id=consent_id,
+            recipient=recipient,
+            source=source,
+            basis=basis,
+        )
+
+
+        consent_response.additional_properties = d
+        return consent_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/create_erasure_request_response_create_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="CreateErasureRequestResponseCreateErasureRequest")
+
+
+
+@_attrs_define
+class CreateErasureRequestResponseCreateErasureRequest:
+    """
+     """
+
+    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)
+        create_erasure_request_response_create_erasure_request = cls(
+        )
+
+
+        create_erasure_request_response_create_erasure_request.additional_properties = d
+        return create_erasure_request_response_create_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/create_in.py

@@ -0,0 +1,119 @@
+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="CreateIn")
+
+
+
+@_attrs_define
+class CreateIn:
+    """
+        Attributes:
+            name (str):
+            external_client_id (Union[None, Unset, str]):
+            workspace_slug (Union[None, Unset, str]):
+     """
+
+    name: str
+    external_client_id: Union[None, Unset, str] = UNSET
+    workspace_slug: Union[None, Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        external_client_id: Union[None, Unset, str]
+        if isinstance(self.external_client_id, Unset):
+            external_client_id = UNSET
+        else:
+            external_client_id = self.external_client_id
+
+        workspace_slug: Union[None, Unset, str]
+        if isinstance(self.workspace_slug, Unset):
+            workspace_slug = UNSET
+        else:
+            workspace_slug = self.workspace_slug
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "name": name,
+        })
+        if external_client_id is not UNSET:
+            field_dict["external_client_id"] = external_client_id
+        if workspace_slug is not UNSET:
+            field_dict["workspace_slug"] = workspace_slug
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        def _parse_external_client_id(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)
+
+        external_client_id = _parse_external_client_id(d.pop("external_client_id", UNSET))
+
+
+        def _parse_workspace_slug(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)
+
+        workspace_slug = _parse_workspace_slug(d.pop("workspace_slug", UNSET))
+
+
+        create_in = cls(
+            name=name,
+            external_client_id=external_client_id,
+            workspace_slug=workspace_slug,
+        )
+
+
+        create_in.additional_properties = d
+        return create_in
+
+    @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/dead_letter_response.py

@@ -0,0 +1,205 @@
+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="DeadLetterResponse")
+
+
+
+@_attrs_define
+class DeadLetterResponse:
+    """ Everything needed to understand a failure — and nothing more.
+
+    Deliberately excludes `payload`: it carries the tenant's message content,
+    and a list endpoint is the wrong place to spray it. It is still stored, and
+    still what gets replayed.
+
+        Attributes:
+            attempt_count (int):
+            destination_url (str):
+            event_id (str):
+            failed_at (Union[None, datetime.datetime]):
+            last_error (Union[None, str]):
+            last_replayed_at (Union[None, datetime.datetime]):
+            last_response_code (Union[None, int]):
+            outbox_id (UUID):
+            replay_count (int):
+     """
+
+    attempt_count: int
+    destination_url: str
+    event_id: str
+    failed_at: Union[None, datetime.datetime]
+    last_error: Union[None, str]
+    last_replayed_at: Union[None, datetime.datetime]
+    last_response_code: Union[None, int]
+    outbox_id: UUID
+    replay_count: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        attempt_count = self.attempt_count
+
+        destination_url = self.destination_url
+
+        event_id = self.event_id
+
+        failed_at: Union[None, str]
+        if isinstance(self.failed_at, datetime.datetime):
+            failed_at = self.failed_at.isoformat()
+        else:
+            failed_at = self.failed_at
+
+        last_error: Union[None, str]
+        last_error = self.last_error
+
+        last_replayed_at: Union[None, str]
+        if isinstance(self.last_replayed_at, datetime.datetime):
+            last_replayed_at = self.last_replayed_at.isoformat()
+        else:
+            last_replayed_at = self.last_replayed_at
+
+        last_response_code: Union[None, int]
+        last_response_code = self.last_response_code
+
+        outbox_id = str(self.outbox_id)
+
+        replay_count = self.replay_count
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "attempt_count": attempt_count,
+            "destination_url": destination_url,
+            "event_id": event_id,
+            "failed_at": failed_at,
+            "last_error": last_error,
+            "last_replayed_at": last_replayed_at,
+            "last_response_code": last_response_code,
+            "outbox_id": outbox_id,
+            "replay_count": replay_count,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        attempt_count = d.pop("attempt_count")
+
+        destination_url = d.pop("destination_url")
+
+        event_id = d.pop("event_id")
+
+        def _parse_failed_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                failed_at_type_0 = isoparse(data)
+
+
+
+                return failed_at_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        failed_at = _parse_failed_at(d.pop("failed_at"))
+
+
+        def _parse_last_error(data: object) -> Union[None, str]:
+            if data is None:
+                return data
+            return cast(Union[None, str], data)
+
+        last_error = _parse_last_error(d.pop("last_error"))
+
+
+        def _parse_last_replayed_at(data: object) -> Union[None, datetime.datetime]:
+            if data is None:
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                last_replayed_at_type_0 = isoparse(data)
+
+
+
+                return last_replayed_at_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, datetime.datetime], data)
+
+        last_replayed_at = _parse_last_replayed_at(d.pop("last_replayed_at"))
+
+
+        def _parse_last_response_code(data: object) -> Union[None, int]:
+            if data is None:
+                return data
+            return cast(Union[None, int], data)
+
+        last_response_code = _parse_last_response_code(d.pop("last_response_code"))
+
+
+        outbox_id = UUID(d.pop("outbox_id"))
+
+
+
+
+        replay_count = d.pop("replay_count")
+
+        dead_letter_response = cls(
+            attempt_count=attempt_count,
+            destination_url=destination_url,
+            event_id=event_id,
+            failed_at=failed_at,
+            last_error=last_error,
+            last_replayed_at=last_replayed_at,
+            last_response_code=last_response_code,
+            outbox_id=outbox_id,
+            replay_count=replay_count,
+        )
+
+
+        dead_letter_response.additional_properties = d
+        return dead_letter_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