peak-sdk 1.0.0__py3-none-any.whl

peak/cli/ruff.toml

@@ -0,0 +1,11 @@
+extend = '../../pyproject.toml'
+src = ["."]
+ignore = [
+  "UP007", # typer is not PEP-585 and PEP-604 compliant
+  "D208",
+  "FBT001",
+  "FBT002",
+  "FBT003",
+  "RSE102"
+]
+unfixable = []

peak/cli/version.py

@@ -0,0 +1,49 @@
+#
+# # 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>
+#
+"""Version command for peak-cli."""
+import platform
+import sys
+
+import typer
+from peak import __version__
+from rich.console import Console
+
+console = Console()
+
+
+def display_version(print_version: bool) -> None:
+    """Display version of this tool.
+
+    Args:
+        print_version (bool): Print version and exit
+
+    Raises:
+        Exit: Exit the program
+    """
+    if print_version:
+        peak_version = __version__
+        major = sys.version_info.major
+        minor = sys.version_info.minor
+        micro = sys.version_info.micro
+        python_version = f"Python=={major}.{minor}.{micro}"
+        platform_version = f"System=={platform.system()}({platform.release()})"
+        console.print(f"peak-cli=={peak_version}\n{python_version}\n{platform_version}")
+        raise typer.Exit()

peak/compression.py

@@ -0,0 +1,162 @@
+#
+# # 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>
+#
+"""Compression module to create zip file to be used as artifact."""
+from __future__ import annotations
+
+import contextlib
+import os
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Iterator, Optional, Set
+
+from pathspec import PathSpec
+
+from peak import constants, exceptions
+
+ZIP_COMPRESSION = zipfile.ZIP_DEFLATED
+
+
+@contextlib.contextmanager
+def compress(path: str, ignore_files: Optional[list[str]] = None) -> Iterator[tempfile.SpooledTemporaryFile[bytes]]:
+    """Creates compressed zip of the files in path.
+
+    Args:
+        path (str): Path of the folder to create zip file.
+        ignore_files (Optional[list[str]]): Ignorefiles to use when creating zip file.
+
+    Yields:
+        Iterator[tempfile.SpooledTemporaryFile[bytes]]: Bytes of the zip file in chunks.
+
+    Raises:
+        InvalidPathException: Given path is invalid and cannot be traversed.
+        FileLimitExceededException: Compressed directory size exceeded the max limits.
+    """
+    path_obj = Path(path)
+    if not path_obj.is_dir():
+        raise exceptions.InvalidPathException(path, "Either the path does not exist or is not a directory.")
+    included_files = get_files_to_include(path, ignore_files)
+    parent_directories: Set[Path] = set()
+
+    with tempfile.SpooledTemporaryFile() as tmp_file:
+        with zipfile.ZipFile(tmp_file, "w", compression=ZIP_COMPRESSION) as zf:
+            for file in included_files:
+                zf.write(path_obj / file, file)
+                parent_directories.update(Path(file).parents)
+                if tmp_file.tell() > constants.MAX_ARTIFACT_SIZE_MB * constants.MB:
+                    raise exceptions.FileLimitExceededException(constants.MAX_ARTIFACT_SIZE_MB)
+
+            # include directories as API backend need directories explicitly included
+            relative_root_path = Path(".")
+            if relative_root_path in parent_directories:
+                parent_directories.remove(relative_root_path)
+            for directory in parent_directories:
+                zf.write(path_obj / directory, directory)
+
+        tmp_file.seek(0)
+        yield tmp_file
+
+
+def print_zip_content(zip_file: tempfile.SpooledTemporaryFile[bytes]) -> None:
+    """Prints content of the zip file to stdout.
+
+    Args:
+        zip_file (BinaryIO): Opened zip file in binary format.
+    """
+    with zipfile.ZipFile(zip_file, "r") as zf:
+        zf.printdir()
+
+
+def get_files_to_include(path: str, ignore_files: Optional[list[str]] = None) -> Iterator[str]:
+    """Get a list of file paths to be included.
+
+    Args:
+        path (str): Root path from where to start the traversal.
+        ignore_files (Optional[list[str]]): Path of ignorefiles to use, defaults to .dockerignore.
+
+    Yields:
+        Iterator[str]: Path of files to be included.
+    """
+    path_obj = Path(path)
+    ignore_pathspec = _load_ignore_patterns(path_obj, ignore_files)
+    yield from ignore_pathspec.match_tree(path, follow_links=True)
+
+
+def _reverse_pattern(pattern: str) -> str:
+    """Converts the inclusion pattern to exclusion and vice-versa.
+
+    This is needed because PathSpec will return the files that matches the patterns
+    but we want the opposite, i.e. we want to exclude the files which match the
+    patterns in ignorefiles.
+
+    Args:
+        pattern (str): Pattern to process
+
+    Returns:
+        str: Processed pattern
+    """
+    pattern = pattern.strip()
+    if not pattern or pattern.startswith("#"):
+        return pattern
+    if pattern.startswith("!"):
+        return pattern[1:]
+    return "!" + pattern
+
+
+def _load_ignore_patterns(path_obj: Path, ignore_files: Optional[list[str]]) -> PathSpec:
+    """Reads ignorefiles and loads all patterns into PathSpec.
+
+    Args:
+        path_obj (Path): Root path relative to which ignore_files would be searched.
+        ignore_files (list[str]): Path of ignorefiles relative to where the script is running
+
+    Returns:
+        PathSpec: PathSpec object with all patterns
+
+    Raises:
+        InvalidPathException: Given path is invalid and cannot be traversed.
+    """
+    if ignore_files is None or len(ignore_files) == 0:
+        # use .dockerignore as default if no ignore file is provided
+        default_ignore = path_obj / ".dockerignore"
+        ignore_files = [os.fspath(default_ignore)] if default_ignore.exists() else []
+
+    all_patterns: list[str] = [
+        "*",
+    ]  # include everything, apply ignore patterns on top of it, if this is given nothing will be included
+    for ignore_file in ignore_files:
+        ignore_file_path = path_obj / ignore_file
+        normalized_ignore_path = ignore_file_path.resolve().relative_to(path_obj.resolve())
+        # ignorefiles should only be at root level
+        if len(normalized_ignore_path.parents) != 1:
+            raise exceptions.InvalidPathException(
+                ignore_file,
+                "Ignore file should be present at root level of given path.",
+            )
+
+        patterns = ignore_file_path.open("r").read().splitlines()
+        all_patterns.extend(
+            map(
+                _reverse_pattern,
+                patterns,
+            ),
+        )
+    return PathSpec.from_lines("gitwildmatch", all_patterns)

peak/config.py

@@ -0,0 +1,24 @@
+#
+# # 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>
+#
+"""Basic Configuration details for the SDK/CLI."""
+from peak.constants import Sources
+
+SOURCE = Sources.SDK

peak/constants.py

@@ -0,0 +1,105 @@
+#
+# # 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>
+#
+"""Contains constants which are used across SDK modules."""
+from __future__ import annotations
+
+from enum import Enum, auto
+from logging import Formatter
+from typing import Any, List, Literal, TypedDict
+
+MB = 2**20
+MAX_ARTIFACT_SIZE_MB: int = 10
+DOWNLOAD_CHUNK_SIZE = 128
+
+LOG_FORMAT = Formatter("%(asctime)s %(name)s %(levelname)s: %(message)s")
+LOG_LEVELS = Literal["CRITICAL", "FATAL", "ERROR", "WARNING", "WARN", "INFO", "DEBUG"]
+
+
+class _ArtifactGlob(TypedDict, total=False):
+    ignore_files: list[str]
+
+
+class ArtifactInfo(_ArtifactGlob):
+    """TypedDict with all required fields for artifact creation.
+
+    path: Path to the file or folder that will be compressed and used as artifact.
+    ignore_files: Ignore files to be used when creating artifact.
+    """
+
+    path: str
+
+
+class AutoName(Enum):
+    """Enum with automatic name() values."""
+
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: List[Any]) -> str:  # noqa: ARG004
+        """Automatically generate enum values from names."""
+        return str(name).lower()
+
+
+class Stage(AutoName):
+    """Enum of all supported platform stages."""
+
+    DEV = auto()
+    LATEST = auto()
+    TEST = auto()
+    BETA = auto()
+    PROD = auto()
+    PARVATI = auto()
+
+
+class ContentType(Enum):
+    """Enum of supported content type for http request to API."""
+
+    APPLICATION_JSON = "application/json"
+    MULTIPART_FORM_DATA = "multipart/form-data"
+
+
+class HttpMethods(AutoName):
+    """Enum of supported HTTP methods."""
+
+    GET = auto()
+    POST = auto()
+    PUT = auto()
+    PATCH = auto()
+    DELETE = auto()
+
+
+class Sources(AutoName):
+    """Enum of the sources for telemetry call."""
+
+    SDK = auto()
+    CLI = auto()
+
+
+__all__: List[str] = [
+    "MB",
+    "MAX_ARTIFACT_SIZE_MB",
+    "DOWNLOAD_CHUNK_SIZE",
+    "LOG_FORMAT",
+    "ArtifactInfo",
+    "Stage",
+    "ContentType",
+    "HttpMethods",
+    "LOG_LEVELS",
+    "Sources",
+]

peak/exceptions.py

@@ -0,0 +1,217 @@
+#
+# # 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>
+#
+"""Exceptions for the Peak API."""
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+from typing import Any, ClassVar, Dict, List, Optional, Tuple, Type
+
+
+class PeakBaseException(Exception):
+    """Base exception class for the Peak SDK."""
+
+    ...
+
+
+class HttpExceptionsRegistryMeta(type):
+    """Registry metaclass."""
+
+    REGISTRY: Dict[int, Any] = defaultdict(lambda: Exception)
+
+    def __new__(
+        cls: "Type[HttpExceptionsRegistryMeta]",
+        name: str,
+        bases: Tuple[Any, ...],
+        attrs: Dict[str, Any],
+    ) -> HttpExceptionsRegistryMeta:
+        """This method runs whenever a new class (that uses this class as its metaclass) is defined.
+
+        This method automatically adds the exception classes to its Registry.
+        It uses the `STATUS_CODE` 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:
+            HttpExceptionsRegistryMeta: the child class itself, forward annotated for type checking
+        """
+        new_cls: "HttpExceptionsRegistryMeta" = type.__new__(cls, name, bases, attrs)
+        status_code: Optional[int] = attrs.get("STATUS_CODE", None)
+        if status_code:
+            cls.REGISTRY[status_code] = new_cls
+        return new_cls
+
+
+class BaseHttpException(PeakBaseException, metaclass=HttpExceptionsRegistryMeta):
+    """Base registry class for registering all exceptions."""
+
+    STATUS_CODE: ClassVar[int]
+
+
+class BadRequestException(BaseHttpException):
+    """The provided inputs are invalid."""
+
+    STATUS_CODE = 400
+
+
+class UnauthorizedException(BaseHttpException):
+    """The authentication credentials are invalid or expired."""
+
+    STATUS_CODE = 401
+
+
+class ForbiddenException(BaseHttpException):
+    """User does not have permissions to perform the operation."""
+
+    STATUS_CODE = 403
+
+
+class NotFoundException(BaseHttpException):
+    """Resource does not exist."""
+
+    STATUS_CODE = 404
+
+
+class ConflictException(BaseHttpException):
+    """There is a conflict with the current state of the target resource."""
+
+    STATUS_CODE = 409
+
+
+class PayloadTooLargeException(BaseHttpException):
+    """The provided file size is larger than the maximum limits."""
+
+    STATUS_CODE = 413
+
+
+class UnprocessableEntityException(BaseHttpException):
+    """The server understands the request, but it was unable to process the contained instructions."""
+
+    STATUS_CODE = 422
+
+
+class InternalServerErrorException(BaseHttpException):
+    """The server encountered an unexpected condition that prevented it from fulfilling the request."""
+
+    STATUS_CODE = 500
+
+
+class InvalidPathException(PeakBaseException):
+    """The provided path is invalid and cannot be processed."""
+
+    def __init__(self, path: str | Path, message: str = "") -> None:
+        """Throw exception with custom message.
+
+        Args:
+            path (str | Path): Path which is invalid.
+            message (str): Any extra message to add to exception.
+        """
+        super().__init__(f"Invalid path: {path!r}. {message}")
+
+
+class MissingEnvironmentVariableException(PeakBaseException):
+    """Required environment variable not found."""
+
+    def __init__(self, env_var: str, *, message: str = "") -> None:
+        """Throw exception with custom message.
+
+        Args:
+            env_var (str): Name of env variable which is not present.
+            message (str): Any extra message to add to exception.
+        """
+        error_message: str = f"{env_var} environment variable is not set or is empty."
+        super().__init__(f"{error_message} {message}")
+
+
+class FileLimitExceededException(PeakBaseException):
+    """Limits on the file are exceeded."""
+
+    def __init__(self, max_size: int | float, *, message: str = "", units: str = "MB") -> None:
+        """Throw exception with custom message.
+
+        Args:
+            max_size (int): Maximum size of the file.
+            message (str): Additional message to add to exception.
+            units (str): Units of the maximum size.
+        """
+        error_message: str = f"Compressed directory size is over {max_size}{units}."
+        super().__init__(f"{error_message} {message}")
+
+
+class InvalidTemplateException(PeakBaseException):
+    """The given template is invalid and could not be compiled."""
+
+    def __init__(self, message: str) -> None:
+        """Throw exception with custom message.
+
+        Args:
+            message (str): Message of the exception.
+        """
+        super().__init__(message)
+
+
+class BadParameterException(PeakBaseException):
+    """Raises exception for invalid parameters."""
+
+    def __init__(self, param: str, *, message: str = "") -> None:
+        """Throw exception with custom message.
+
+        Args:
+            param (str): Raw parameter input from the CLI.
+            message (str): Additional message to add to exception.
+        """
+        error_message: str = f"Unable to parse: {param}"
+        super().__init__(f"{error_message} {message}")
+
+
+class InvalidParameterException(PeakBaseException):
+    """Raises exception for invalid parameters."""
+
+    def __init__(self, *, message: str = "") -> None:
+        """Throw exception with custom message.
+
+        Args:
+            message (str): Additional message to add to exception.
+        """
+        super().__init__(message)
+
+
+__all__: List[str] = [
+    "HttpExceptionsRegistryMeta",
+    "BaseHttpException",
+    "BadRequestException",
+    "UnauthorizedException",
+    "ForbiddenException",
+    "NotFoundException",
+    "ConflictException",
+    "PayloadTooLargeException",
+    "UnprocessableEntityException",
+    "InternalServerErrorException",
+    "InvalidPathException",
+    "MissingEnvironmentVariableException",
+    "FileLimitExceededException",
+    "BadParameterException",
+    "InvalidParameterException",
+]