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

kelvin/api/client/api/control_change.py

@@ -0,0 +1,398 @@
+"""
+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 ControlChange(DataModelBase):
+    @classmethod
+    def get_control_change_clustering(
+        cls,
+        data: Optional[Union[requests.ControlChangeClusteringGet, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> List[responses.ControlChangeClustering]:
+        """
+        Retrieve the total count of Control Changes matching an array of `resources` and filter options between two dates grouped by the parameter `time_bucket`. Will also return a list of all the Control Change `id`s counted.
+
+        **Permission Required:** `kelvin.permission.control_change.read`.
+
+        ``getControlChangeClustering``: ``POST`` ``/api/v4/control-changes/clustering/get``
+
+        Parameters
+        ----------
+        data: requests.ControlChangeClusteringGet, optional
+        **kwargs:
+            Extra parameters for requests.ControlChangeClusteringGet
+              - get_control_change_clustering: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/control-changes/clustering/get",
+            {},
+            {},
+            {},
+            {},
+            data,
+            "requests.ControlChangeClusteringGet",
+            False,
+            {"200": List[responses.ControlChangeClustering], "400": None, "401": None, "404": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def create_control_change(
+        cls,
+        data: Optional[Union[requests.ControlChangeCreate, Mapping[str, Any]]] = None,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> responses.ControlChangeCreate:
+        """
+        Send a new value to be written to an Asset / Data Stream pair. The Control Change Manager will automatically find which Cluster and Bridge to communicate the change to.
+
+        **Permission Required:** `kelvin.permission.control_change.create`.
+
+        ``createControlChange``: ``POST`` ``/api/v4/control-changes/create``
+
+        Parameters
+        ----------
+        data: requests.ControlChangeCreate, optional
+        **kwargs:
+            Extra parameters for requests.ControlChangeCreate
+              - create_control_change: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/control-changes/create",
+            {},
+            {},
+            {},
+            {},
+            data,
+            "requests.ControlChangeCreate",
+            False,
+            {"201": responses.ControlChangeCreate, "400": None, "401": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result
+
+    @classmethod
+    def get_control_change_last(
+        cls,
+        status_limit: Optional[int] = 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,
+        data: Optional[Union[requests.ControlChangeLastGet, Mapping[str, Any]]] = None,
+        fetch: bool = True,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> Union[List[responses.ControlChangeGet], responses.ControlChangeLastGetPaginatedResponseCursor]:
+        """
+        Returns a dictionary with a data property containing an array of latest Control Change objects. Only the latest Control Changes for each `resource` in the request filters will be returned.
+
+        **Permission Required:** `kelvin.permission.control_change.read`.
+
+        ``getControlChangeLast``: ``POST`` ``/api/v4/control-changes/last/get``
+
+        Parameters
+        ----------
+        status_limit : :obj:`int`
+            Maximum number of status logs to fetched per Control Change object,
+            starting from most recent logs created.
+        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]`
+        data: requests.ControlChangeLastGet, optional
+        **kwargs:
+            Extra parameters for requests.ControlChangeLastGet
+              - get_control_change_last: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/control-changes/last/get",
+            {},
+            {
+                "status_limit": status_limit,
+                "pagination_type": pagination_type,
+                "page_size": page_size,
+                "page": page,
+                "next": next,
+                "previous": previous,
+                "direction": direction,
+                "sort_by": sort_by,
+            },
+            {},
+            {},
+            data,
+            "requests.ControlChangeLastGet",
+            False,
+            {"200": responses.ControlChangeLastGetPaginatedResponseCursor, "400": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result.fetch("/api/v4/control-changes/last/get", "POST", data) if fetch and not _dry_run else result
+
+    @classmethod
+    def list_control_changes(
+        cls,
+        status_limit: Optional[int] = 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,
+        data: Optional[Union[requests.ControlChangesList, Mapping[str, Any]]] = None,
+        fetch: bool = True,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> Union[List[responses.ControlChangeGet], responses.ControlChangesListPaginatedResponseCursor]:
+        """
+        Returns a list of Control Change objects for specific Asset / Data Stream pairs or Control Change IDs. The list can be optionally filtered and sorted on the server before being returned.
+
+        **Permission Required:** `kelvin.permission.control_change.read`.
+
+        ``listControlChanges``: ``POST`` ``/api/v4/control-changes/list``
+
+        Parameters
+        ----------
+        status_limit : :obj:`int`
+            Maximum number of status logs to fetched per Control Change object,
+            starting from most recent logs created.
+        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]`
+        data: requests.ControlChangesList, optional
+        **kwargs:
+            Extra parameters for requests.ControlChangesList
+              - list_control_changes: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/control-changes/list",
+            {},
+            {
+                "status_limit": status_limit,
+                "pagination_type": pagination_type,
+                "page_size": page_size,
+                "page": page,
+                "next": next,
+                "previous": previous,
+                "direction": direction,
+                "sort_by": sort_by,
+            },
+            {},
+            {},
+            data,
+            "requests.ControlChangesList",
+            False,
+            {"200": responses.ControlChangesListPaginatedResponseCursor, "400": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result.fetch("/api/v4/control-changes/list", "POST", data) if fetch and not _dry_run else result
+
+    @classmethod
+    def get_control_change_range(
+        cls,
+        status_limit: Optional[int] = 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,
+        data: Optional[Union[requests.ControlChangeRangeGet, Mapping[str, Any]]] = None,
+        fetch: bool = True,
+        _dry_run: bool = False,
+        _client: Any = None,
+        **kwargs: Any,
+    ) -> Union[List[responses.ControlChangeGet], responses.ControlChangeRangeGetPaginatedResponseCursor]:
+        """
+        Returns a dictionary with a data property containing an array of Control Changes within a specified time range for all of the `resources` in the `resources` array that match the filter options.
+
+        **Permission Required:** `kelvin.permission.control_change.read`.
+
+        ``getControlChangeRange``: ``POST`` ``/api/v4/control-changes/range/get``
+
+        Parameters
+        ----------
+        status_limit : :obj:`int`
+            Maximum number of status logs to fetched per Control Change object,
+            starting from most recent logs created.
+        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]`
+        data: requests.ControlChangeRangeGet, optional
+        **kwargs:
+            Extra parameters for requests.ControlChangeRangeGet
+              - get_control_change_range: dict
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "post",
+            "/api/v4/control-changes/range/get",
+            {},
+            {
+                "status_limit": status_limit,
+                "pagination_type": pagination_type,
+                "page_size": page_size,
+                "page": page,
+                "next": next,
+                "previous": previous,
+                "direction": direction,
+                "sort_by": sort_by,
+            },
+            {},
+            {},
+            data,
+            "requests.ControlChangeRangeGet",
+            False,
+            {"200": responses.ControlChangeRangeGetPaginatedResponseCursor, "400": None},
+            False,
+            _dry_run,
+            kwargs,
+        )
+        return result.fetch("/api/v4/control-changes/range/get", "POST", data) if fetch and not _dry_run else result
+
+    @classmethod
+    def get_control_change(
+        cls, control_change_id: str, status_limit: Optional[int] = None, _dry_run: bool = False, _client: Any = None
+    ) -> responses.ControlChangeGet:
+        """
+        Retrieves the properties, status and all associated logs of a Control Change.
+
+        **Permission Required:** `kelvin.permission.control_change.read`.
+
+        ``getControlChange``: ``GET`` ``/api/v4/control-changes/{control_change_id}/get``
+
+        Parameters
+        ----------
+        control_change_id : :obj:`str`, optional
+            A unique random generated UUID as the key `id` for the Control Change.
+        status_limit : :obj:`int`
+            Maximum number of status logs to fetched per Control Change object,
+            starting from most recent logs created.
+
+        """
+
+        from ..model import responses
+
+        result = cls._make_request(
+            _client,
+            "get",
+            "/api/v4/control-changes/{control_change_id}/get",
+            {"control_change_id": control_change_id},
+            {"status_limit": status_limit},
+            {},
+            {},
+            None,
+            None,
+            False,
+            {"200": responses.ControlChangeGet, "400": None, "404": None},
+            False,
+            _dry_run,
+        )
+        return result