kelvin-python-api-client 0.0.1__py3-none-any.whl

kelvin/api/client/api/secret.py

@@ -0,0 +1,173 @@
+"""
+Kelvin API Client.
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Mapping, Optional, Sequence, Union
+
+from typing_extensions import Literal
+
+from kelvin.api.client.data_model import DataModelBase
+
+from ..model import requests, responses
+
+
+class Secret(DataModelBase):
+    @classmethod
+    def create_secret(
+        cls,
+        data: Optional[Union[requests.SecretCreate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.SecretCreate:
+        """
+        Create a new Secret.
+
+        Once this is created you can not change or see the value itself from Kelvin API. Retrieval of the value can only be done through an App.
+
+        **Permission Required:** `kelvin.permission.secret.create`.
+
+        ``createSecret``: ``POST`` ``/api/v4/secrets/create``
+
+        Parameters
+        ----------
+        data: requests.SecretCreate, optional
+        **kwargs:
+            Extra parameters for requests.SecretCreate
+              - create_secret: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/secrets/create",
+            {},
+            {},
+            {},
+            {},
+            data,
+            "requests.SecretCreate",
+            False,
+            {"201": responses.SecretCreate, "400": None, "401": None, "409": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def list_secrets(
+        cls,
+        search: Optional[Sequence[str]] = None,
+        pagination_type: Optional[Literal["limits", "cursor", "stream"]] = None,
+        page_size: Optional[int] = 10000,
+        page: Optional[int] = None,
+        next: Optional[str] = None,
+        previous: Optional[str] = None,
+        direction: Optional[Literal["asc", "desc"]] = None,
+        sort_by: Optional[Sequence[str]] = None,
+        fetch: bool = True,
+        _dry_run: bool = False,
+        _client: Any = None,
+    ) -> Union[List[responses.SecretItem], responses.SecretsListPaginatedResponseCursor]:
+        """
+        Returns a list of Secrets. The actual Secret itself can not be retrieved here and is only available from an App.
+
+        **Permission Required:** `kelvin.permission.secret.read`.
+
+        ``listSecrets``: ``GET`` ``/api/v4/secrets/list``
+
+        Parameters
+        ----------
+        search : :obj:`Sequence[str]`
+            Search and filter on the list based on the key `name`. The search is
+            case sensitive but will find partial matches anywhere in the `name`.
+        pagination_type : :obj:`Literal['limits', 'cursor', 'stream']`
+            Method of pagination to use for return results where `total_items` is
+            greater than `page_size`. `cursor` and `limits` will return one `page`
+            of results, `stream` will return all results. ('limits', 'cursor',
+            'stream')
+        page_size : :obj:`int`
+            Number of objects to be returned in each page. Page size can range
+            between 1 and 1000 objects.
+        page : :obj:`int`
+            An integer for the wanted page of results. Used only with
+            `pagination_type` set as `limits`.
+        next : :obj:`str`
+            An alphanumeric string bookmark to indicate where to start for the
+            next page. Used only with `pagination_type` set as `cursor`.
+        previous : :obj:`str`
+            An alphanumeric string bookmark to indicate where to end for the
+            previous page. Used only with `pagination_type` set as `cursor`.
+        direction : :obj:`Literal['asc', 'desc']`
+            Sorting order according to the `sort_by` parameter. ('asc', 'desc')
+        sort_by : :obj:`Sequence[str]`
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/secrets/list",
+            {},
+            {
+                "search": search,
+                "pagination_type": pagination_type,
+                "page_size": page_size,
+                "page": page,
+                "next": next,
+                "previous": previous,
+                "direction": direction,
+                "sort_by": sort_by,
+            },
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.SecretsListPaginatedResponseCursor, "400": None, "401": None},
+            False,
+            _dry_run,
+        )
+        return result.fetch("/api/v4/secrets/list", "GET") if fetch and not _dry_run else result
+
+    @classmethod
+    def delete_secret(cls, secret_name: str, _dry_run: bool = False, _client: Any = None) -> None:
+        """
+        Permanently delete a Secret. This cannot be undone once the API request has been submitted.
+
+        **Permission Required:** `kelvin.permission.secret.delete`.
+
+        ``deleteSecret``: ``POST`` ``/api/v4/secrets/{secret_name}/delete``
+
+        Parameters
+        ----------
+        secret_name : :obj:`str`, optional
+            Secret key `name` to delete. The string can only contain lowercase
+            alphanumeric characters and `.`, `_` or `-` characters.
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/secrets/{secret_name}/delete",
+            {"secret_name": secret_name},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": None, "400": None, "401": None, "404": None},
+            False,
+            _dry_run,
+        )
+        return result

kelvin/api/client/api/thread.py

@@ -0,0 +1,435 @@
+"""
+Kelvin API Client.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Mapping, Optional, Union
+
+from typing_extensions import Literal
+
+from kelvin.api.client.data_model import DataModelBase
+
+from ..model import requests, responses
+
+
+class Thread(DataModelBase):
+    @classmethod
+    def create_thread(
+        cls,
+        data: Optional[Union[requests.ThreadCreate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.ThreadCreate:
+        """
+        Create Thread
+
+        **Permission Required:** `kelvin.permission.thread.create`.
+
+        ``createThread``: ``POST`` ``/api/v4/threads/create``
+
+        Parameters
+        ----------
+        data: requests.ThreadCreate, optional
+        **kwargs:
+            Extra parameters for requests.ThreadCreate
+              - create_thread: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/create",
+            {},
+            {},
+            {},
+            {},
+            data,
+            "requests.ThreadCreate",
+            False,
+            {"201": responses.ThreadCreate, "400": None, "401": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def list_threads(
+        cls,
+        type: Optional[str] = None,
+        related_to: Optional[str] = None,
+        user_id: Optional[str] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+    ) -> responses.ThreadsList:
+        """
+        List Threads
+
+        **Pagination Sortable Columns:** `thread.id`
+
+        **Permission Required:** `kelvin.permission.thread.read`.
+
+        ``listThreads``: ``GET`` ``/api/v4/threads/list``
+
+        Parameters
+        ----------
+        type : :obj:`str`
+            Filter threads by type
+        related_to : :obj:`str`
+            Filter threads by related_to
+        user_id : :obj:`str`
+            Filter threads by user_id
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/threads/list",
+            {},
+            {"type": type, "related_to": related_to, "user_id": user_id},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.ThreadsList, "400": None, "401": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def delete_thread(cls, thread_id: str, _dry_run: bool = False, _client: Any = None) -> None:
+        """
+        Delete Thread
+
+        **Permission Required:** `kelvin.permission.thread.delete`.
+
+        ``deleteThread``: ``POST`` ``/api/v4/threads/{thread_id}/delete``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/delete",
+            {"thread_id": thread_id},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": None, "400": None, "403": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def update_thread_follow(
+        cls, thread_id: str, follow: Optional[bool] = None, _dry_run: bool = False, _client: Any = None
+    ) -> responses.ThreadFollowUpdate:
+        """
+        Update Thread Follow
+
+        **Permission Required:** `kelvin.permission.thread.read`.
+
+        ``updateThreadFollow``: ``POST`` ``/api/v4/threads/{thread_id}/follow/update``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        follow : :obj:`bool`
+            Set user follow value to true or false
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/follow/update",
+            {"thread_id": thread_id},
+            {"follow": follow},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.ThreadFollowUpdate, "404": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def get_thread(cls, thread_id: str, _dry_run: bool = False, _client: Any = None) -> responses.ThreadGet:
+        """
+        Get Thread
+
+        **Permission Required:** `kelvin.permission.thread.read`.
+
+        ``getThread``: ``GET`` ``/api/v4/threads/{thread_id}/get``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/threads/{thread_id}/get",
+            {"thread_id": thread_id},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.ThreadGet, "404": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def create_thread_reply(
+        cls,
+        thread_id: str,
+        reply_id: Optional[str] = None,
+        data: Optional[Union[requests.ThreadReplyCreate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.ThreadReplyCreate:
+        """
+        Create Thread Reply
+
+        **Permission Required:** `kelvin.permission.thread.create`.
+
+        ``createThreadReply``: ``POST`` ``/api/v4/threads/{thread_id}/replies/create``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        reply_id : :obj:`str`
+            Reply ID
+        data: requests.ThreadReplyCreate, optional
+        **kwargs:
+            Extra parameters for requests.ThreadReplyCreate
+              - create_thread_reply: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/replies/create",
+            {"thread_id": thread_id},
+            {"reply_id": reply_id},
+            {},
+            {},
+            data,
+            "requests.ThreadReplyCreate",
+            False,
+            {"200": responses.ThreadReplyCreate, "400": None, "401": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def delete_thread_reply(cls, thread_id: str, reply_id: str, _dry_run: bool = False, _client: Any = None) -> str:
+        """
+        Delete Thread Reply
+
+        **Permission Required:** `kelvin.permission.thread.delete`.
+
+        ``deleteThreadReply``: ``POST`` ``/api/v4/threads/{thread_id}/replies/{reply_id}/delete``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        reply_id : :obj:`str`, optional
+            Reply ID
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/replies/{reply_id}/delete",
+            {"thread_id": thread_id, "reply_id": reply_id},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": str, "400": None, "401": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def update_thread_reply(
+        cls,
+        thread_id: str,
+        reply_id: str,
+        data: Optional[Union[requests.ThreadReplyUpdate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.ThreadReplyUpdate:
+        """
+        Update Thread Reply
+
+        **Permission Required:** `kelvin.permission.thread.update`.
+
+        ``updateThreadReply``: ``POST`` ``/api/v4/threads/{thread_id}/replies/{reply_id}/update``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        reply_id : :obj:`str`, optional
+            Reply ID
+        data: requests.ThreadReplyUpdate, optional
+        **kwargs:
+            Extra parameters for requests.ThreadReplyUpdate
+              - update_thread_reply: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/replies/{reply_id}/update",
+            {"thread_id": thread_id, "reply_id": reply_id},
+            {},
+            {},
+            {},
+            data,
+            "requests.ThreadReplyUpdate",
+            False,
+            {"200": responses.ThreadReplyUpdate, "400": None, "401": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def update_thread_seen(
+        cls, thread_id: str, seen: Optional[bool] = None, _dry_run: bool = False, _client: Any = None
+    ) -> responses.ThreadSeenUpdate:
+        """
+        Update Thread Seen
+
+        **Permission Required:** `kelvin.permission.thread.read`.
+
+        ``updateThreadSeen``: ``POST`` ``/api/v4/threads/{thread_id}/seen/update``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        seen : :obj:`bool`
+            Set user seen value to true or false
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/seen/update",
+            {"thread_id": thread_id},
+            {"seen": seen},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.ThreadSeenUpdate, "404": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def update_thread(
+        cls,
+        thread_id: str,
+        data: Optional[Union[requests.ThreadUpdate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.ThreadUpdate:
+        """
+        Update Thread
+
+        **Permission Required:** `kelvin.permission.thread.update`.
+
+        ``updateThread``: ``POST`` ``/api/v4/threads/{thread_id}/update``
+
+        Parameters
+        ----------
+        thread_id : :obj:`str`, optional
+            Thread ID
+        data: requests.ThreadUpdate, optional
+        **kwargs:
+            Extra parameters for requests.ThreadUpdate
+              - update_thread: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/threads/{thread_id}/update",
+            {"thread_id": thread_id},
+            {},
+            {},
+            {},
+            data,
+            "requests.ThreadUpdate",
+            False,
+            {"200": responses.ThreadUpdate, "400": None, "401": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result