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

kelvin/api/client/api/asset_insights.py

@@ -0,0 +1,67 @@
+"""
+Kelvin API Client.
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Mapping, Optional, Union
+
+from typing_extensions import Literal
+
+from kelvin.api.client.data_model import DataModelBase
+
+from ..model import requests, responses
+
+
+class AssetInsights(DataModelBase):
+    @classmethod
+    def get_asset_insights(
+        cls,
+        page_size: Optional[int] = 10000,
+        page: Optional[int] = None,
+        data: Optional[Union[requests.AssetInsightsGet, Mapping[str, Any]]] = None,
+        fetch: bool = True,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> Union[List[responses.AssetInsightsItem], responses.AssetInsightsGetPaginated]:
+        """
+        Advanced Asset Insights collates Asset data and optional custom defined fields and returns a structured array of Asset related objects. Ideal for generating UI lists, it accommodates a range of search, filter, and optional data on Data Streams, Parameters, Control Changes, Recommendations, etc. related to the Asset.
+
+        **Permission Required:** `kelvin.permission.asset_insights.read`.
+
+        ``getAssetInsights``: ``POST`` ``/api/v4/asset-insights/get``
+
+        Parameters
+        ----------
+        page_size : :obj:`int`
+            Number of Asset objects to be returned.
+        page : :obj:`int`
+            Return the list of Asset objects on requested page using the
+            `page_size` as a page calculation reference.
+        data: requests.AssetInsightsGet, optional
+        **kwargs:
+            Extra parameters for requests.AssetInsightsGet
+              - get_asset_insights: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/asset-insights/get",
+            {},
+            {"page_size": page_size, "page": page},
+            {},
+            {},
+            data,
+            "requests.AssetInsightsGet",
+            False,
+            {"200": responses.AssetInsightsGetPaginated, "400": None, "424": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result.fetch("/api/v4/asset-insights/get", "POST", data) if fetch and not _dry_run else result

kelvin/api/client/api/bridge.py

@@ -0,0 +1,306 @@
+"""
+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 Bridge(DataModelBase):
+    @classmethod
+    def deploy_bridge(
+        cls,
+        data: Optional[Union[requests.BridgeDeploy, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.BridgeDeploy:
+        """
+        Deploy a Bridge (Connection) from the App Registry as a Workload to a Cluster/Node.
+
+        **Permission Required:** `kelvin.permission.bridge.create`.
+
+        ``deployBridge``: ``POST`` ``/api/v4/bridges/deploy``
+
+        Parameters
+        ----------
+        data: requests.BridgeDeploy, optional
+        **kwargs:
+            Extra parameters for requests.BridgeDeploy
+              - deploy_bridge: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/bridges/deploy",
+            {},
+            {},
+            {},
+            {},
+            data,
+            "requests.BridgeDeploy",
+            False,
+            {"201": responses.BridgeDeploy, "400": None, "401": None, "409": None, "424": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def list_bridges(
+        cls,
+        names: Optional[Sequence[str]] = None,
+        search: Optional[Sequence[str]] = None,
+        cluster_name: Optional[Sequence[str]] = None,
+        workload_name: Optional[Sequence[str]] = None,
+        status_state: Optional[Sequence[str]] = None,
+        app_name: Optional[Sequence[str]] = None,
+        app_version: 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.BridgeItem], responses.BridgesListPaginatedResponseCursor]:
+        """
+        Returns a list of Bridges (also known as Connections) and its parameters. The list can be optionally filtered and sorted on the server before being returned.
+
+        **Permission Required:** `kelvin.permission.bridge.read`.
+
+        ``listBridges``: ``GET`` ``/api/v4/bridges/list``
+
+        Parameters
+        ----------
+        names : :obj:`Sequence[str]`
+            A filter on the list based on the key `name`. The filter is on the
+            full name only. The string can only contain lowercase alphanumeric
+            characters and `.`, `_` or `-` characters.
+        search : :obj:`Sequence[str]`
+            Search and filter on the list based on the keys `name`, `title`
+            (Display Name), `cluster_name`, `node_name` and `workload_name`. All
+            strings in the array are treated as `OR`. The search is case
+            insensitive and will find partial matches as well.
+        cluster_name : :obj:`Sequence[str]`
+            A filter on the list based on the key `cluster_name`. The filter is on
+            the full name only. The string can only contain lowercase alphanumeric
+            characters and `.`, `_` or `-` characters. If set, it will override
+            acp_name
+        workload_name : :obj:`Sequence[str]`
+            A filter on the list based on the key `workload_name`. The filter is
+            on the full name only. The string can only contain lowercase
+            alphanumeric characters and `.`, `_` or `-` characters.
+        status_state : :obj:`Sequence[str]`
+            A filter on the list based on the key `state` in the `status` object.
+            The filter is on the full name only. The string can only contain
+            lowercase alphanumeric characters and `.`, `_` or `-` characters.
+        app_name : :obj:`Sequence[str]`
+            Unique identifier `name` of the App. The string can only contain
+            lowercase alphanumeric characters and `.`, `_` or `-` characters.
+        app_version : :obj:`Sequence[str]`
+            App version
+        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/bridges/list",
+            {},
+            {
+                "names": names,
+                "search": search,
+                "cluster_name": cluster_name,
+                "workload_name": workload_name,
+                "status_state": status_state,
+                "app_name": app_name,
+                "app_version": app_version,
+                "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.BridgesListPaginatedResponseCursor, "400": None, "401": None},
+            False,
+            _dry_run,
+        )
+        return result.fetch("/api/v4/bridges/list", "GET") if fetch and not _dry_run else result
+
+    @classmethod
+    def delete_bridge(cls, bridge_name: str, _dry_run: bool = False, _client: Any = None) -> None:
+        """
+        Permanently delete an existing Bridge (Connection). You will no longer receieve Asset / Data Stream data from the assets associated with the Bridge (Connection). This cannot be undone once the API request has been submitted.
+
+        **Permission Required:** `kelvin.permission.bridge.delete`.
+
+        ``deleteBridge``: ``POST`` ``/api/v4/bridges/{bridge_name}/delete``
+
+        Parameters
+        ----------
+        bridge_name : :obj:`str`, optional
+            Unique identifier `name` of the Bridge (Connection).
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/bridges/{bridge_name}/delete",
+            {"bridge_name": bridge_name},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": None, "400": None, "401": None, "404": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def get_bridge(cls, bridge_name: str, _dry_run: bool = False, _client: Any = None) -> responses.BridgeGet:
+        """
+        Retrieve the parameters of a Bridge (Connection).
+
+        **Permission Required:** `kelvin.permission.bridge.read`.
+
+        ``getBridge``: ``GET`` ``/api/v4/bridges/{bridge_name}/get``
+
+        Parameters
+        ----------
+        bridge_name : :obj:`str`, optional
+            Unique identifier `name` of the Bridge (Connection).
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/bridges/{bridge_name}/get",
+            {"bridge_name": bridge_name},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.BridgeGet, "400": None, "401": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def start_bridge(cls, bridge_name: str, _dry_run: bool = False, _client: Any = None) -> None:
+        """
+        Start running the Bridge (Connection).
+
+        **Permission Required:** `kelvin.permission.bridge.update`.
+
+        ``startBridge``: ``GET`` ``/api/v4/bridges/{bridge_name}/start``
+
+        Parameters
+        ----------
+        bridge_name : :obj:`str`, optional
+            Unique identifier `name` of the Bridge (Connection).
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/bridges/{bridge_name}/start",
+            {"bridge_name": bridge_name},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": None, "400": None, "401": None, "404": None},
+            False,
+            _dry_run,
+        )
+        return result
+
+    @classmethod
+    def stop_bridge(cls, bridge_name: str, _dry_run: bool = False, _client: Any = None) -> None:
+        """
+        Stop running the Bridge (Connection).
+        **Permission Required:** `kelvin.permission.bridge.update`.
+
+        ``stopBridge``: ``GET`` ``/api/v4/bridges/{bridge_name}/stop``
+
+        Parameters
+        ----------
+        bridge_name : :obj:`str`, optional
+            Unique identifier `name` of the Bridge (Connection).
+
+        """
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/bridges/{bridge_name}/stop",
+            {"bridge_name": bridge_name},
+            {},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": None, "400": None, "401": None, "404": None},
+            False,
+            _dry_run,
+        )
+        return result