daknode 0.1.0__py3-none-any.whl

daknode/models/revoke_response_revoke.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="RevokeResponseRevoke")
+
+
+
+@_attrs_define
+class RevokeResponseRevoke:
+    """
+     """
+
+    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)
+        revoke_response_revoke = cls(
+        )
+
+
+        revoke_response_revoke.additional_properties = d
+        return revoke_response_revoke
+
+    @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/search_match.py

@@ -0,0 +1,170 @@
+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
+from uuid import UUID
+
+
+
+
+
+
+T = TypeVar("T", bound="SearchMatch")
+
+
+
+@_attrs_define
+class SearchMatch:
+    """
+        Attributes:
+            chunk_end (int):
+            chunk_index (int):
+            chunk_start (int):
+            inbox_id (UUID):
+            message_id (UUID):
+            risk_level (str):
+            risk_signals (Union[None, list[str]]):
+            similarity (float):
+            thread_id (UUID):
+     """
+
+    chunk_end: int
+    chunk_index: int
+    chunk_start: int
+    inbox_id: UUID
+    message_id: UUID
+    risk_level: str
+    risk_signals: Union[None, list[str]]
+    similarity: float
+    thread_id: UUID
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        chunk_end = self.chunk_end
+
+        chunk_index = self.chunk_index
+
+        chunk_start = self.chunk_start
+
+        inbox_id = str(self.inbox_id)
+
+        message_id = str(self.message_id)
+
+        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
+
+        similarity = self.similarity
+
+        thread_id = str(self.thread_id)
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "chunk_end": chunk_end,
+            "chunk_index": chunk_index,
+            "chunk_start": chunk_start,
+            "inbox_id": inbox_id,
+            "message_id": message_id,
+            "risk_level": risk_level,
+            "risk_signals": risk_signals,
+            "similarity": similarity,
+            "thread_id": thread_id,
+        })
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        chunk_end = d.pop("chunk_end")
+
+        chunk_index = d.pop("chunk_index")
+
+        chunk_start = d.pop("chunk_start")
+
+        inbox_id = UUID(d.pop("inbox_id"))
+
+
+
+
+        message_id = UUID(d.pop("message_id"))
+
+
+
+
+        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"))
+
+
+        similarity = d.pop("similarity")
+
+        thread_id = UUID(d.pop("thread_id"))
+
+
+
+
+        search_match = cls(
+            chunk_end=chunk_end,
+            chunk_index=chunk_index,
+            chunk_start=chunk_start,
+            inbox_id=inbox_id,
+            message_id=message_id,
+            risk_level=risk_level,
+            risk_signals=risk_signals,
+            similarity=similarity,
+            thread_id=thread_id,
+        )
+
+
+        search_match.additional_properties = d
+        return search_match
+
+    @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/search_request.py

@@ -0,0 +1,107 @@
+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="SearchRequest")
+
+
+
+@_attrs_define
+class SearchRequest:
+    """
+        Attributes:
+            query (str):
+            min_score (Union[None, Unset, float]):
+            top_k (Union[Unset, int]):  Default: 10.
+     """
+
+    query: str
+    min_score: Union[None, Unset, float] = UNSET
+    top_k: Union[Unset, int] = 10
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        query = self.query
+
+        min_score: Union[None, Unset, float]
+        if isinstance(self.min_score, Unset):
+            min_score = UNSET
+        else:
+            min_score = self.min_score
+
+        top_k = self.top_k
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "query": query,
+        })
+        if min_score is not UNSET:
+            field_dict["min_score"] = min_score
+        if top_k is not UNSET:
+            field_dict["top_k"] = top_k
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        query = d.pop("query")
+
+        def _parse_min_score(data: object) -> Union[None, Unset, float]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(Union[None, Unset, float], data)
+
+        min_score = _parse_min_score(d.pop("min_score", UNSET))
+
+
+        top_k = d.pop("top_k", UNSET)
+
+        search_request = cls(
+            query=query,
+            min_score=min_score,
+            top_k=top_k,
+        )
+
+
+        search_request.additional_properties = d
+        return search_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/search_response.py

@@ -0,0 +1,124 @@
+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 dateutil.parser import isoparse
+from typing import cast
+from typing import Union
+import datetime
+
+if TYPE_CHECKING:
+  from ..models.search_match import SearchMatch
+
+
+
+
+
+T = TypeVar("T", bound="SearchResponse")
+
+
+
+@_attrs_define
+class SearchResponse:
+    """
+        Attributes:
+            generated_at (datetime.datetime):
+            matches (list['SearchMatch']):
+            model (str):
+            index_is_eventually_consistent (Union[Unset, bool]):  Default: True.
+     """
+
+    generated_at: datetime.datetime
+    matches: list['SearchMatch']
+    model: str
+    index_is_eventually_consistent: Union[Unset, bool] = True
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.search_match import SearchMatch
+        generated_at = self.generated_at.isoformat()
+
+        matches = []
+        for matches_item_data in self.matches:
+            matches_item = matches_item_data.to_dict()
+            matches.append(matches_item)
+
+
+
+        model = self.model
+
+        index_is_eventually_consistent = self.index_is_eventually_consistent
+
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({
+            "generated_at": generated_at,
+            "matches": matches,
+            "model": model,
+        })
+        if index_is_eventually_consistent is not UNSET:
+            field_dict["index_is_eventually_consistent"] = index_is_eventually_consistent
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.search_match import SearchMatch
+        d = dict(src_dict)
+        generated_at = isoparse(d.pop("generated_at"))
+
+
+
+
+        matches = []
+        _matches = d.pop("matches")
+        for matches_item_data in (_matches):
+            matches_item = SearchMatch.from_dict(matches_item_data)
+
+
+
+            matches.append(matches_item)
+
+
+        model = d.pop("model")
+
+        index_is_eventually_consistent = d.pop("index_is_eventually_consistent", UNSET)
+
+        search_response = cls(
+            generated_at=generated_at,
+            matches=matches,
+            model=model,
+            index_is_eventually_consistent=index_is_eventually_consistent,
+        )
+
+
+        search_response.additional_properties = d
+        return search_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/send_request.py

@@ -0,0 +1,162 @@
+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="SendRequest")
+
+
+
+@_attrs_define
+class SendRequest:
+    """ `extra="forbid"` is load-bearing.
+
+    There is no `from`, `sender` or `return_path` field: the From identity comes
+    from the tenant's inbox record. Forbidding extras makes a caller who tries to
+    set one get a `422` instead of a silent `202` — being ignored is worse,
+    because the integrator believes they chose a sender and nothing says
+    otherwise. A caller-chosen From is sender spoofing on infrastructure whose
+    DKIM signature makes it look authentic.
+
+        Attributes:
+            inbox_id (UUID):
+            to (str):
+            body_html (Union[None, Unset, str]):
+            body_text (Union[None, Unset, str]):
+            subject (Union[Unset, str]):  Default: ''.
+            thread_id (Union[None, UUID, Unset]):
+     """
+
+    inbox_id: UUID
+    to: str
+    body_html: Union[None, Unset, str] = UNSET
+    body_text: Union[None, Unset, str] = UNSET
+    subject: Union[Unset, str] = ''
+    thread_id: Union[None, UUID, Unset] = UNSET
+
+
+
+
+
+    def to_dict(self) -> dict[str, Any]:
+        inbox_id = str(self.inbox_id)
+
+        to = self.to
+
+        body_html: Union[None, Unset, str]
+        if isinstance(self.body_html, Unset):
+            body_html = UNSET
+        else:
+            body_html = self.body_html
+
+        body_text: Union[None, Unset, str]
+        if isinstance(self.body_text, Unset):
+            body_text = UNSET
+        else:
+            body_text = self.body_text
+
+        subject = self.subject
+
+        thread_id: Union[None, Unset, str]
+        if isinstance(self.thread_id, Unset):
+            thread_id = UNSET
+        elif isinstance(self.thread_id, UUID):
+            thread_id = str(self.thread_id)
+        else:
+            thread_id = self.thread_id
+
+
+        field_dict: dict[str, Any] = {}
+
+        field_dict.update({
+            "inbox_id": inbox_id,
+            "to": to,
+        })
+        if body_html is not UNSET:
+            field_dict["body_html"] = body_html
+        if body_text is not UNSET:
+            field_dict["body_text"] = body_text
+        if subject is not UNSET:
+            field_dict["subject"] = subject
+        if thread_id is not UNSET:
+            field_dict["thread_id"] = thread_id
+
+        return field_dict
+
+
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        inbox_id = UUID(d.pop("inbox_id"))
+
+
+
+
+        to = d.pop("to")
+
+        def _parse_body_html(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)
+
+        body_html = _parse_body_html(d.pop("body_html", UNSET))
+
+
+        def _parse_body_text(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)
+
+        body_text = _parse_body_text(d.pop("body_text", UNSET))
+
+
+        subject = d.pop("subject", UNSET)
+
+        def _parse_thread_id(data: object) -> Union[None, UUID, Unset]:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, str):
+                    raise TypeError()
+                thread_id_type_0 = UUID(data)
+
+
+
+                return thread_id_type_0
+            except: # noqa: E722
+                pass
+            return cast(Union[None, UUID, Unset], data)
+
+        thread_id = _parse_thread_id(d.pop("thread_id", UNSET))
+
+
+        send_request = cls(
+            inbox_id=inbox_id,
+            to=to,
+            body_html=body_html,
+            body_text=body_text,
+            subject=subject,
+            thread_id=thread_id,
+        )
+
+        return send_request

daknode/models/send_response_send.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="SendResponseSend")
+
+
+
+@_attrs_define
+class SendResponseSend:
+    """
+     """
+
+    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)
+        send_response_send = cls(
+        )
+
+
+        send_response_send.additional_properties = d
+        return send_response_send
+
+    @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