peak-sdk 1.0.0__py3-none-any.whl

peak/handler.py

@@ -0,0 +1,358 @@
+#
+# # Copyright © 2023 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+"""Handler for sending requests to the API."""
+from __future__ import annotations
+
+import contextlib
+from abc import ABC, ABCMeta, abstractmethod
+from typing import Any, Callable, ClassVar, Dict, Iterator, List, Optional, Tuple, Type, TypeVar, Union
+
+import requests
+from requests.adapters import HTTPAdapter
+from requests_toolbelt import MultipartEncoder, MultipartEncoderMonitor, user_agent
+from rich.progress import BarColumn, Progress, TaskProgressColumn, TextColumn
+from urllib3.util import Retry
+
+from peak.compression import compress
+from peak.constants import ContentType, HttpMethods
+from peak.exceptions import BaseHttpException
+from peak.telemetry import telemetry
+from peak.validators import check_file_size
+
+from ._version import __version__
+
+T = TypeVar("T")
+Serializable = Dict[str, Union[str, int, float, bool]]
+OptionalSerializable = Optional[Serializable]
+
+
+class HandlerRegistryMeta(type):
+    """Metaclass for registering all types of Handler classes."""
+
+    REGISTRY: Dict[ContentType, BaseHandler] = {}
+
+    def __new__(
+        cls: "Type[HandlerRegistryMeta]",
+        name: str,
+        bases: Tuple[Any, ...],
+        attrs: Dict[str, Any],
+    ) -> HandlerRegistryMeta:
+        """This method runs whenever a new class (that uses this class as its metaclass) is defined.
+
+        This method automatically adds the handler classes to its Registry.
+        It uses the `CONTENT_TYPE` attribute of the class as key and the class itself as value in registry.
+        Ref: https://charlesreid1.github.io/python-patterns-the-registry.html
+
+        Args:
+            name (str): Name of the child class
+            bases (tuple): Tuple of the child class's inheritance tree
+            attrs (dict): Name and value pairs of all the attributes defined in the child class
+
+        Returns:
+            HandlerRegistryMeta: the class itself, forward annotated for type checking
+
+        Raises:
+            TypeError: if the child class does not have a `CONTENT_TYPE` attribute
+        """
+        error_invalid_content_type: str = f"Invalid content type for {name} handler"
+        new_cls: "HandlerRegistryMeta" = type.__new__(cls, name, bases, attrs)
+
+        content_type: Optional[ContentType] = attrs.get("CONTENT_TYPE", None)
+        try:
+            if content_type and ContentType(content_type):
+                cls.REGISTRY[content_type] = new_cls()
+        except ValueError as err:
+            raise TypeError(error_invalid_content_type) from err
+        else:
+            return new_cls
+
+
+class _CombinedMeta(HandlerRegistryMeta, ABCMeta):
+    """Utility class for combining multiple meta-classes."""
+
+    ...
+
+
+class AuthRetrySession(requests.Session):
+    """Session with extra sugar attached."""
+
+    # used in testing, so we can modify the backoff_factor etc. to speed up the tests
+    _DEFAULT_RETRY_CONFIG: Dict[str, Any] = {
+        "backoff_factor": 2,
+        "total": 5,
+        "status_forcelist": [500, 502, 503, 504],
+    }
+
+    def _add_retries(self, retry_config: Optional[Dict[str, Any]] = None) -> None:
+        if retry_config is None:
+            retry_config = self._DEFAULT_RETRY_CONFIG
+        adapter = HTTPAdapter(max_retries=Retry(**retry_config))
+        self.mount("https://", adapter=adapter)
+
+
+class HandlerUtils(AuthRetrySession):
+    """Utility class for handling requests."""
+
+    @contextlib.contextmanager
+    def make_artifact(
+        self,
+        path: Optional[str],
+        body: Dict[str, Any],
+        ignore_files: Optional[list[str]],
+    ) -> Iterator[MultipartEncoderMonitor]:
+        """Create a multipart/form-data encoded file with given body and path as file.
+
+        Args:
+            path (Optional[str]): path to the file or folder that will be compressed and used as artifact
+            ignore_files(Optional[list[str]]): Ignore files to be used when creating artifact
+            body (Dict[str, Any]): body content to be sent with artifact
+
+        Yields:
+            MultipartEncoderMonitor: MultipartEncoderMonitor generator object
+        """
+        if path:
+            with compress(path, ignore_files) as fh:
+                check_file_size(fh)
+                encoder = MultipartEncoder(
+                    {
+                        **body,
+                        "artifact": (
+                            "artifact.zip",
+                            fh,
+                            "application/zip",
+                        ),
+                    },
+                )
+                callback = self._default_callback(encoder)
+                monitor = MultipartEncoderMonitor(encoder, callback)
+                yield monitor
+        else:
+            encoder = MultipartEncoder({**body})
+            monitor = MultipartEncoderMonitor(encoder)
+            yield monitor
+
+    make_artifact.__annotations__["return"] = contextlib.AbstractContextManager
+
+    def _default_callback(self, encoder: MultipartEncoder) -> Callable[[MultipartEncoderMonitor], None]:
+        progress = Progress(
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+        )
+        progress.start()
+        bar = progress.add_task("[green]Uploading", total=encoder.len)
+
+        def callback(monitor: MultipartEncoderMonitor) -> None:
+            progress.update(bar, completed=monitor.bytes_read, refresh=True)
+            progress.refresh()
+            if monitor.bytes_read >= monitor.len:
+                progress.stop()
+                progress.console.clear_live()
+
+        return callback
+
+    @staticmethod
+    def parse_args(arguments: Dict[str, Any]) -> Dict[str, Any]:
+        """Parse arguments dict and remove the parameters whose values are not provided.
+
+        Args:
+            arguments (Dict[str, Any]): dictionary of arguments
+
+        Returns:
+            Dict[str, Any]: filtered dictionary where value is not None
+        """
+        return {k: v for k, v in arguments.items() if v is not None}
+
+    @staticmethod
+    def handle_response(response: requests.Response) -> requests.Response:
+        """Handles the response from the API.
+
+        Args:
+            response (requests.Response): response object from the API
+
+        Returns:
+            requests.Response: response of the request.
+
+        # noqa: DAR401
+        Raises:
+            BaseHttpException: The HTTP exception based on status code
+        """
+        if 200 <= response.status_code < 300:  # noqa: PLR2004
+            return response
+
+        raise BaseHttpException.REGISTRY[response.status_code](response.json())
+
+
+class BaseHandler(ABC, HandlerUtils, metaclass=_CombinedMeta):
+    """Abstract base class for all handler type classes."""
+
+    CONTENT_TYPE: ClassVar[ContentType]
+
+    @abstractmethod
+    def handle(
+        self,
+        url: str,
+        method: HttpMethods,
+        *,
+        headers: Dict[str, str],
+        params: Optional[Dict[str, Any]],
+        body: Optional[Dict[str, Any]],
+        path: Optional[str],
+        ignore_files: Optional[list[str]],
+        request_kwargs: OptionalSerializable,
+    ) -> requests.Response:
+        """Placeholder handle method."""
+        ...
+
+
+class MultipartFormDataHandler(BaseHandler):
+    """Handles requests with multipart/form-data content type."""
+
+    CONTENT_TYPE = ContentType.MULTIPART_FORM_DATA
+
+    def handle(
+        self,
+        url: str,
+        method: HttpMethods,
+        *,
+        path: Optional[str],
+        headers: Dict[str, str],
+        body: Optional[Dict[str, Any]],
+        params: Optional[Dict[str, Any]] = None,  # noqa: ARG002
+        ignore_files: Optional[list[str]] = None,
+        request_kwargs: OptionalSerializable = None,
+    ) -> requests.Response:
+        """Handle multipart/form-data requests.
+
+        Args:
+            url (str): url to send the request to
+            method (HttpMethods): method to use for the request, e.g. get, post, put, delete
+            headers (Dict[str, str]): headers to send with the request
+            params (Dict[str, Any]): params to send to the request, not used for multipart/form-data
+            body (Dict[str, Any]): body to send to the request
+            path (Optional[str]): path to the file or folder that will be compressed and used as artifact
+            request_kwargs (OptionalSerializable): extra arguments to be passed when making the request, defaults to None
+            ignore_files(Optional[list[str]]): Ignore files to be used when creating artifact
+
+        Returns:
+            requests.Response: response of the request
+        """
+        with self.make_artifact(path, self.parse_args(body or {}), ignore_files) as monitor:
+            headers = {**headers, "Content-Type": monitor.content_type}
+            response: Any = getattr(requests, method.value)(url, data=monitor, headers=headers, **request_kwargs)
+        return self.handle_response(response)
+
+
+class ApplicationJsonHandler(BaseHandler):
+    """Handles requests with application/json content type."""
+
+    CONTENT_TYPE = ContentType.APPLICATION_JSON
+
+    def handle(
+        self,
+        url: str,
+        method: HttpMethods,
+        *,
+        headers: Dict[str, str],
+        params: Optional[Dict[str, Any]],
+        body: Optional[Dict[str, Any]],
+        path: Optional[str] = None,  # noqa: ARG002
+        ignore_files: Optional[list[str]] = None,  # noqa: ARG002
+        request_kwargs: OptionalSerializable = None,
+    ) -> requests.Response:
+        """Handle application/json requests.
+
+        Args:
+            url (str): url to send the request to
+            method (HttpMethods): method to use for the request, e.g. get, post, put, delete
+            headers (Dict[str, str]): headers to send with the request
+            params (Dict[str, Any]): params to send to the request
+            body (Dict[str, Any]): body to send to the request
+            path (Optional[str]): path to the file or folder that will be compressed and used as artifact, not used in application/json handler
+            request_kwargs (OptionalSerializable): extra arguments to be passed when making the request, defaults to None
+            ignore_files(Optional[list[str]]): Ignore files to be used when creating artifact
+
+        Returns:
+            requests.Response: response of the request.
+        """
+        headers = {**headers, "Content-Type": self.CONTENT_TYPE.value}
+        response: Any = getattr(requests, method.value)(
+            url,
+            params=self.parse_args(params or {}),
+            json=body,
+            headers=headers,
+            **request_kwargs,
+        )
+        return self.handle_response(response)
+
+
+class Handler:
+    """Handler class to handle requests to the API."""
+
+    USER_AGENT: str = user_agent(__package__ or __name__, __version__)
+
+    @telemetry
+    def make_request(
+        self,
+        url: str,
+        method: HttpMethods,
+        content_type: ContentType,
+        headers: Optional[Dict[str, str]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        body: Optional[Dict[str, Any]] = None,
+        path: Optional[str] = None,
+        request_kwargs: Optional[Dict[str, int | bool | str | float]] = None,
+        ignore_files: Optional[list[str]] = None,
+    ) -> requests.Response:
+        """Redirects the request to the appropriate strategy based on the content type.
+
+        Args:
+            url (str): url to send the request to
+            method (HttpMethods): The HTTP method to use, e.g. get, post, put, delete
+            content_type (ContentType): content type of the request
+            headers (Dict[str, str]): headers to send with the request
+            params (Dict[str, Any]): params to send to the request
+            body (Dict[str, Any]): body to send to the request
+            path (Optional[str]): path to the file or folder that will be compressed and used as artifact, defaults to None
+            request_kwargs(Dict[str, int | bool | str | float] | None): extra arguments to be passed when making the request.
+            ignore_files(Optional[list[str]]): Ignore files to be used when creating artifact
+
+        Returns:
+            requests.Response: response json
+        """
+        headers = {"User-Agent": self.USER_AGENT} if headers is None else {**headers, "User-Agent": self.USER_AGENT}
+        params = params or {}
+        body = body or {}
+        request_kwargs = request_kwargs or {}
+
+        return BaseHandler.REGISTRY[content_type].handle(
+            url=url,
+            method=method,
+            headers=headers,
+            params=params,
+            body=body,
+            path=path,
+            request_kwargs=request_kwargs,
+            ignore_files=ignore_files,
+        )
+
+
+__all__: List[str] = ["Handler", "ApplicationJsonHandler", "MultipartFormDataHandler"]

peak/helpers.py

@@ -0,0 +1,184 @@
+#
+# # Copyright © 2023 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+
+"""Collection of basic helper functions."""
+from __future__ import annotations
+
+import inspect
+import json
+from types import FrameType
+from typing import Any, Dict, List, Optional
+
+
+def parse_body_for_multipart_request(body: Dict[str, Any]) -> Dict[str, str]:
+    """Parses an object to make it suitable for passing in a multipart request.
+
+    Args:
+        body (Dict[str, Any]): the object to be parsed
+
+    Returns:
+        Dict[str, str]: the parsed object
+    """
+    return {key: (value if type(value) == str else json.dumps(value)) for (key, value) in body.items()}
+
+
+def remove_keys(body: Dict[str, Any], keys: List[str]) -> Dict[str, Any]:
+    """Removes given keys from a dictionary.
+
+    Args:
+        body (Dict[str, Any]): the object to be parsed
+        keys (List[str]): the keys to remove
+
+    Returns:
+        Dict[str, str]: the final object with required keys removed
+    """
+    return {key: value for (key, value) in body.items() if key not in keys}
+
+
+def get_base_domain(stage: str, subdomain: Optional[str] = "service") -> str:
+    """Gets the base domain for a stage with the given subdomain.
+
+    Args:
+        stage (str): the stage
+        subdomain (Optional[str]): the subdomain
+
+    Returns:
+        str: the final base domain
+    """
+    if stage == "prod":
+        stage = ""
+    elif stage == "latest":
+        stage = "dev"
+
+    domain: str = f"https://{subdomain}.{stage}.peak.ai"
+    domain = domain.replace("..", ".")  # for prod domain
+    return domain
+
+
+def parse_list_of_strings(param: List[str] | None) -> List[str] | None:
+    """Split comma separated strings in the list and flatten that list.
+
+    Args:
+       param (List[str] | None): List of strings
+
+    Returns:
+        List[Any] | None: The final flattened list
+    """
+    if param is None or len(param) == 0:
+        return param
+
+    result: List[str] = []
+    for e in param:
+        result = result + e.split(",")
+
+    return result
+
+
+def snake_case_to_lower_camel_case(snake_case_string: str) -> str:
+    """Converts underscore string to lower camel case.
+
+    Args:
+        snake_case_string (str): string in underscore
+
+    Returns:
+        str: lower camel case string
+    """
+    parts = snake_case_string.split("_")
+    return parts[0] + "".join(part.capitalize() for part in parts[1:])
+
+
+def variables_to_dict(*args: Any, frame: FrameType | None = None) -> Dict[str, str]:
+    """Converts arbitary variables to a dictonary.
+
+    Args:
+        args (str|int): tuple of string|int variables
+        frame (FrameType|None): Current Frame of caller
+
+    Returns:
+        Dict[str, str]: Dictionary containing key value pair of variables
+    """
+    if frame is None:
+        frame = inspect.currentframe()
+        if frame:
+            # set frame to previous
+            frame = frame.f_back
+
+    var_dict = {}
+    if frame and frame.f_locals:
+        for var_name, var_value in frame.f_locals.items():
+            if var_value in args and var_value:
+                var_dict[snake_case_to_lower_camel_case(var_name)] = var_value
+
+    del frame  # Explicitly release the frame to avoid reference cycles
+    return var_dict
+
+
+def combine_dictionaries(
+    dict1: Dict[str, Any],
+    dict2: Dict[str, Any],
+    nested_keys_to_skip: Optional[List[str]] = [],  # noqa: B006
+) -> Dict[str, Any]:
+    """Combines two dictonaries. Values for second dictonary have higer precedence.
+
+    Args:
+        dict1 (Dict[str, Any]): dictionary 1
+        dict2 (Dict[str, Any]): dictonary 2
+        nested_keys_to_skip (List[str] | None): Keys for which nested combining is not required.
+
+    Returns:
+        Dict[str, Any]: Combined dictionary
+    """
+    if not dict1:
+        return dict2
+
+    combined_dict = dict(dict1)
+    for key in dict2:
+        if key in combined_dict and type(combined_dict[key]) is dict and key not in (nested_keys_to_skip or []):
+            combined_dict[key] = combine_dictionaries(combined_dict[key], dict2[key])
+        else:
+            combined_dict[key] = dict2[key]
+    return combined_dict
+
+
+def map_user_options(
+    user_options: Dict[str, Any],
+    mapping: Dict[str, str],
+    dict_type_keys: List[str] = [],  # noqa: B006
+) -> Dict[str, Any]:
+    """Maps user provided inputs to a specific format.
+
+    Args:
+        user_options (Dict[str, Any]): Dictionary containing user inputs
+        mapping (Dict[str, Any]): Mapping to be used for conversion
+        dict_type_keys (List[str]): List of keys which have json type values
+
+    Returns:
+        Dict[str, str]: Mappe dictionary
+    """
+    result: Dict[str, Any] = {}
+    for key in user_options:
+        if key in mapping:
+            nested_dict = result[mapping[key]] if mapping[key] in result else {}
+            nested_dict[key] = json.loads(user_options[key]) if key in dict_type_keys else user_options[key]
+            result[mapping[key]] = nested_dict
+        else:
+            result[key] = json.loads(user_options[key]) if key in dict_type_keys else user_options[key]
+    return result

peak/logger.py

@@ -0,0 +1,48 @@
+#
+# # Copyright © 2023 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+"""Logger for the Peak SDK."""
+from __future__ import annotations
+
+import logging
+import sys
+from typing import List
+
+from peak.constants import LOG_FORMAT, LOG_LEVELS
+
+logger: logging.Logger = logging.getLogger("peak-sdk")
+stream_handler = logging.StreamHandler(sys.stdout)
+stream_handler.setFormatter(LOG_FORMAT)
+logger.addHandler(stream_handler)
+logger.propagate = False
+
+
+def set_log_level(log_level: LOG_LEVELS) -> None:
+    """Update log level for Peak logger.
+
+    Args:
+        log_level (LOG_LEVELS): new logging level for the logger.
+    """
+    logger.setLevel(log_level)
+    for handler in logger.handlers:
+        handler.setLevel(log_level)
+
+
+__all__: List[str] = ["logger"]

peak/press/__init__.py

@@ -0,0 +1,28 @@
+#
+# # Copyright © 2023 Peak AI Limited. or its affiliates. All Rights Reserved.
+# #
+# # Licensed under the Apache License, Version 2.0 (the "License"). You
+# # may not use this file except in compliance with the License. A copy of
+# # the License is located at:
+# #
+# # https://github.com/PeakBI/peak-sdk/blob/main/LICENSE
+# #
+# # or in the "license" file accompanying this file. This file is
+# # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# # ANY KIND, either express or implied. See the License for the specific
+# # language governing permissions and limitations under the License.
+# #
+# # This file is part of the peak-sdk.
+# # see (https://github.com/PeakBI/peak-sdk)
+# #
+# # You should have received a copy of the APACHE LICENSE, VERSION 2.0
+# # along with this program. If not, see <https://apache.org/licenses/LICENSE-2.0>
+#
+"""This module exports all press services from the `Peak-Platform`."""
+from __future__ import annotations
+
+from typing import List
+
+from peak.press import apps, blocks, deployments, specs
+
+__all__: List[str] = ["apps", "blocks", "deployments", "specs"]