qwak-sdk 0.1.0__py3-none-any.whl → 0.2.20rc0__py3-none-any.whl

qwak_sdk/commands/secrets/secrets_commands_group.py

@@ -0,0 +1,19 @@
+import click
+
+from qwak_sdk.commands.secrets.delete.ui import delete_secret
+from qwak_sdk.commands.secrets.get.ui import get_secret
+from qwak_sdk.commands.secrets.set.ui import set_secret
+
+
+@click.group(
+    "secrets",
+    help="Commands for interacting with the secret store",
+)
+def secrets_commands_group():
+    # Click commands group injection
+    pass
+
+
+secrets_commands_group.add_command(set_secret)
+secrets_commands_group.add_command(get_secret)
+secrets_commands_group.add_command(delete_secret)

qwak_sdk/commands/secrets/set/_logic.py

@@ -0,0 +1,5 @@
+from qwak.clients.secret_service import SecretServiceClient
+
+
+def execute_set_secret(name, value):
+    SecretServiceClient().set_secret(name, value)

qwak_sdk/commands/secrets/set/ui.py

@@ -0,0 +1,16 @@
+import click
+
+from qwak_sdk.commands.secrets.set._logic import execute_set_secret
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("set", cls=QwakCommand)
+@click.option("--name", metavar="TEXT", required=True, help="the secret name")
+@click.option("--value", hide_input=True, confirmation_prompt=False, prompt=True)
+def set_secret(name, value, **kwargs):
+    print(f"Creating secret named '{name}' with value length of {len(value)}...")
+    try:
+        execute_set_secret(name, value)
+        print("Created!")
+    except Exception as e:
+        print(f"Error setting secret. Error is {e}")

qwak_sdk/commands/ui_tools.py

@@ -0,0 +1,18 @@
+from typing import Any, Callable, Iterable, List
+
+from google.protobuf.json_format import MessageToJson
+from tabulate import tabulate
+
+
+def output_as_json(data: Any):
+    print(MessageToJson(data))
+
+
+def output_as_table(
+    data_source: Iterable[Any], data_extractor: Callable, headers: List[str]
+):
+    data = []
+    for item in data_source:
+        data.append(data_extractor(item))
+
+    print(tabulate(data, headers=headers))

qwak_sdk/common/run_config/__init__.py

@@ -0,0 +1,22 @@
+from .base import QwakConfigBase, YamlConfigMixin
+from .utils import (
+    ConfigCliMap,
+    validate_bool,
+    validate_enum,
+    validate_float,
+    validate_int,
+    validate_list_of_strings,
+    validate_string,
+)
+
+__all__ = [
+    "QwakConfigBase",
+    "YamlConfigMixin",
+    "ConfigCliMap",
+    "validate_bool",
+    "validate_enum",
+    "validate_float",
+    "validate_int",
+    "validate_list_of_strings",
+    "validate_string",
+]

qwak_sdk/common/run_config/base.py

@@ -0,0 +1,101 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+from marshmallow_dataclass import class_schema
+from qwak.exceptions import QwakException
+from yaml import Loader, dump, load
+
+from qwak_sdk.common.run_config.utils import ConfigCliMap, rgetattr, rsetattr
+
+
+class QwakConfigBase(ABC):
+    """Base qwak config object."""
+
+    @property
+    @abstractmethod
+    def _config_mapping(self) -> List[ConfigCliMap]:
+        """Config mapping, Return a list of ConfigCliMap object in order to create the mapping.
+
+        Returns:
+            list: List of ConfigCliMap to apply.
+        """
+        pass
+
+    def merge_cli_argument(
+        self, sections: Tuple[str, ...] = (), **kwargs: Dict[str, Any]
+    ):
+        """Merge and validate cli arguments by supplied mapping.
+
+        Args:
+            sections: Sections to validate.
+            **kwargs: argument from cli.
+
+        Raises:
+            QwakException: In case that the argument is not valid.
+        """
+        for prop_map in self._config_mapping:
+            value = kwargs.get(prop_map.key)
+            if value is not None:
+                if isinstance(value, (list, tuple)):
+                    new_value = list(rgetattr(self, prop_map.prop))
+                    new_value.extend(value)
+                    value = new_value
+                rsetattr(self, prop_map.prop, value)
+            if (
+                not sections
+                or any(
+                    list(
+                        map(
+                            lambda section, _prop_map=prop_map: _prop_map.prop.startswith(
+                                section
+                            ),
+                            sections,
+                        )
+                    )
+                )
+                or "." not in prop_map.prop
+            ):
+                config_value = rgetattr(self, prop_map.prop)
+                if not prop_map.validation_func(config_value, prop_map.is_required):
+                    raise QwakException(
+                        f"{prop_map.key} argument contain invalid argument: "
+                        f"{value or config_value}"
+                    )
+        self._post_merge_cli()
+
+    @abstractmethod
+    def _post_merge_cli(self):
+        """Actions to perform after merging cli argument in to properties"""
+        pass
+
+
+class YamlConfigMixin(object):
+    @classmethod
+    def from_yaml(cls, yaml_path: str) -> Any:
+        """Create instance of class from yaml and class scheme.
+
+        Args:
+            yaml_path (str): Yaml path.
+
+        Returns:
+            object: Instance of created class.
+        """
+        if not yaml_path:
+            return cls()
+        schema = class_schema(cls)
+        yaml_content = Path(yaml_path).read_text()
+        yaml_parsed = load(stream=yaml_content, Loader=Loader)
+
+        return schema().load(yaml_parsed)
+
+    def to_yaml(self) -> str:
+        """Convert class by scheme to yaml.
+
+        Returns:
+            str: Class as yaml string by scheme.
+        """
+        loaded_type = type(self)
+        schema = class_schema(loaded_type)
+
+        return dump(schema().dump(self))

qwak_sdk/common/run_config/utils.py

@@ -0,0 +1,249 @@
+import functools
+from collections.abc import Iterable
+from dataclasses import dataclass, field
+from typing import Any, Callable
+
+
+@dataclass
+class ConfigCliMap:
+    """Mapping between cli argument to properties argument.
+
+    Attributes:
+        key (str): key of the argument in the cli.
+        prop (str): property path as nested json object (obj.prop1.prop2)
+        validation_func (Callable): function which accept two parameters value (value to validate and is_required param.
+        is_required (bool): True if value is required else False.
+    """
+
+    key: str
+    prop: str
+    validation_func: Callable = field(default=lambda: True)
+    is_required: bool = False
+
+
+def validate_list_of_strings(value: Any, is_required: bool) -> bool:
+    """Validate if a list include only strings
+
+    Args:
+        value: Value to perform validation on.
+        is_required: True if value is required.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_list_of_strings(["1", "3"], False)
+        True
+        >>> validate_list_of_strings(["1", 3], False)
+        False
+        >>> validate_list_of_strings(None, True)
+        False
+    """
+    if not value and not is_required:
+        return True
+    elif not isinstance(value, Iterable):
+        return False
+
+    return all(isinstance(p, str) for p in value)
+
+
+def validate_string(value: Any, is_required: bool) -> bool:
+    """Validate if value is a string.
+
+    Args:
+        value: Value to perform validation on.
+        is_required: True if value is required.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_string("3", False)
+        True
+        >>> validate_string(3, False)
+        False
+        >>> validate_string(None, True)
+        False
+    """
+    if value:
+        return isinstance(value, str)
+    elif is_required:
+        return False
+
+    return True
+
+
+def validate_float(value: Any, is_required: bool) -> bool:
+    """Validate if value is a float.
+
+    Args:
+        value: Value to perform validation on.
+        is_required: True if value is required.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_float(3, True)
+        True
+        >>> validate_float(3.5, True)
+        True
+        >>> validate_float(None, True)
+        False
+    """
+    if value:
+        return isinstance(value, (float, int))
+    elif is_required:
+        return False
+
+    return True
+
+
+def validate_int(value: Any, is_required: bool) -> bool:
+    """Validate if value is a int.
+
+    Args:
+        value: Value to perform validation on.
+        is_required: True if value is required.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_int(3, True)
+        True
+        >>> validate_int(3.5, True)
+        False
+        >>> validate_int(None, True)
+        False
+    """
+    if value:
+        return isinstance(value, int) or (isinstance(value, str) and value.isdigit())
+    elif is_required:
+        return False
+
+    return True
+
+
+def validate_bool(value: Any, is_required: bool) -> bool:
+    """Validate if value is a boolean.
+
+    Args:
+        value: Value to perform validation on.
+        is_required: True if value is required.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_bool(True, False)
+        True
+        >>> validate_bool("true", False)
+        False
+        >>> validate_bool(None, True)
+        False
+    """
+    if isinstance(value, bool):
+        return True
+    elif is_required:
+        return False
+
+
+def validate_enum(enum: Any) -> Callable:
+    """Create function to validate if value in enum.
+
+    Args:
+        enum: enum to validate on
+
+    Returns:
+        bool: Callable.
+    """
+
+    def validate(value: Any, is_required: bool) -> bool:
+        if value and isinstance(value, str):
+            return value.upper() in enum.__members__
+        elif is_required:
+            return False
+
+        return True
+
+    return validate
+
+
+def validate_variation(value: Any) -> bool:
+    """
+    Args:
+        value: value to perform validation on.
+
+    Returns:
+        bool: True if value is valid.
+    """
+    if not (hasattr(value, "name") and isinstance(value.name, str)):
+        return False
+
+    if not hasattr(value, "traffic"):
+        return False
+
+    if not (
+        hasattr(value.traffic, "percentage")
+        and isinstance(value.traffic.percentage, int)
+    ):
+        return False
+
+    if not (
+        hasattr(value.traffic, "shadow") and isinstance(value.traffic.shadow, bool)
+    ):
+        return False
+
+    return True
+
+
+def validate_variations(value: Any, is_required: bool) -> bool:
+    """Validate if value is a variation.
+
+    Args:
+        value: Value to perform validation on.
+
+    Returns:
+        bool: True if value is valid.
+
+    Examples:
+        >>> validate_variations([DeployConfig.Realtime.VariationConfig(name='default', traffic=DeployConfig.Realtime.VariationConfig.TrafficConfig(percentage=100, shadow=False))], False)
+        True
+        >>> validate_variations(["{variation.name: Test}"], False)
+        False
+        >>> validate_variations(None, True)
+        False
+    """
+    if not value and not is_required:
+        return True
+    elif not isinstance(value, Iterable):
+        return False
+
+    return all(validate_variation(variation) for variation in value)
+
+
+def rsetattr(obj: object, attr: str, val: Any):
+    """Set attribute in object recursively.
+
+    Args:
+        obj: Object to set value in.
+        attr: Nested attributes path to value. (obj.prop1.prop2)
+        val: Value to set in property
+    """
+    pre, _, post = attr.rpartition(".")
+    setattr(rgetattr(obj, pre) if pre else obj, post, val)
+
+
+def rgetattr(obj: object, attr: str, *args) -> Any:
+    """Get attribute in object recursively.
+
+    Args:
+        obj: Object to set value in.
+        attr: Nested attributes path to value. (obj.prop1.prop2)
+    """
+
+    def _getattr(obj, attr):
+        return getattr(obj, attr, *args)
+
+    return functools.reduce(_getattr, [obj] + attr.split("."))

qwak_sdk/exceptions/__init__.py

@@ -0,0 +1,11 @@
+from .qwak_command_exception import QwakCommandException
+from .qwak_general_build_exception import QwakGeneralBuildException
+from .qwak_resource_not_found import QwakResourceNotFound
+from .qwak_suggestion_exception import QwakSuggestionException
+
+__all__ = [
+    "QwakGeneralBuildException",
+    "QwakSuggestionException",
+    "QwakResourceNotFound",
+    "QwakCommandException",
+]

qwak_sdk/exceptions/qwak_command_exception.py

@@ -0,0 +1,2 @@
+class QwakCommandException(Exception):
+    pass

qwak_sdk/exceptions/qwak_deploy_new_build_failed.py

@@ -0,0 +1,5 @@
+from qwak_sdk.exceptions import QwakSuggestionException
+
+
+class QwakDeployNewBuildFailedException(QwakSuggestionException):
+    pass

qwak_sdk/exceptions/qwak_general_build_exception.py

@@ -0,0 +1,13 @@
+class QwakGeneralBuildException(Exception):
+    def __init__(self, message: str, src_exception: Exception = None):
+        self._message = message
+        self._exception_msg = str(src_exception) if src_exception else ""
+
+    @property
+    def message(self) -> str:
+        msg = f"""Message: {self._message}
+Exception message: {self._exception_msg}"""
+        return msg
+
+    def __str__(self):
+        return self.message

qwak_sdk/exceptions/qwak_remote_build_failed.py

@@ -0,0 +1,5 @@
+from qwak_sdk.exceptions import QwakSuggestionException
+
+
+class QwakRemoteBuildFailedException(QwakSuggestionException):
+    pass

qwak_sdk/exceptions/qwak_resource_not_found.py

@@ -0,0 +1,2 @@
+class QwakResourceNotFound(Exception):
+    pass

qwak_sdk/exceptions/qwak_suggestion_exception.py

@@ -0,0 +1,27 @@
+from typing import Optional
+
+
+class QwakSuggestionException(Exception):
+    def __init__(
+        self,
+        message: str,
+        src_exception: Optional[Exception] = None,
+        suggestion: Optional[str] = "",
+    ):
+        self._message = message
+        self._src_exception = str(src_exception) if src_exception else ""
+        self._suggestion = suggestion
+
+    @property
+    def message(self) -> str:
+        if self._src_exception:
+            msg = f"""Message: {self._message}.
+Exception message: {self._src_exception}.
+Recommendation: {self._suggestion}."""
+        else:
+            msg = f"""Message: {self._message}.
+Recommendation: {self._suggestion}."""
+        return msg
+
+    def __str__(self):
+        return self.message

qwak_sdk/inner/file_registry.py

@@ -0,0 +1,97 @@
+import importlib.util
+import os
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+
+from yaspin.core import Yaspin
+
+
+def list_qwak_python_files(path: Path, sp: Yaspin):
+    """
+    Helper function which finds python files with qwak imports in a given module
+
+    Args:
+        path: path to a directory
+        sp: spinner object, used to print
+    Returns:
+        List of python files which use the Qwak SDK
+    """
+
+    file_paths = []
+    if Path.is_dir(path):
+        for object_path in path.glob("**/*.py"):
+            try:
+                if not object_path.is_file():
+                    continue
+                mod_name, file_ext = os.path.splitext(object_path.name)
+                if file_ext != ".py" or mod_name == "setup":
+                    continue
+
+                with object_path.open("rb") as fp:
+                    content = fp.read()
+                    contains_qwak_feature = all(
+                        [token in content for token in (b"qwak")]
+                    )
+
+                if not contains_qwak_feature:
+                    continue
+
+                with _add_to_python_path(object_path):
+                    # Test that the file can be imported cleanly
+                    spec = importlib.util.spec_from_file_location(mod_name, object_path)
+                    if not spec:
+                        sp.write(f"Could not load file: {object_path}. Skipping.")
+                        continue
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+
+                    file_paths.append((mod_name, object_path))
+            except Exception as e:
+                sp.write(
+                    f"Got an error trying to handle the file {object_path}, error is: {e}. Skipping."
+                )
+    return file_paths
+
+
+def extract_class_objects(python_files, clazz):
+    """
+    Helper function which given a list of python files extracts objects of the type `clazz`
+
+    Args
+        python_files: list of python files
+        clazz: class object which its instances should be extracted
+    Returns
+        list of extracted objects of type clazz from the given python files
+    """
+    clazz_objects = []
+    for mod, file in python_files:
+        with _add_to_python_path(Path(file)):
+            spec = importlib.util.spec_from_file_location(mod, file)
+            if not spec:
+                continue
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+            for feature in list(module.__dict__.values()):
+                if isinstance(feature, clazz):
+                    clazz_objects.append((feature, file))
+
+    return clazz_objects
+
+
+@contextmanager
+def _add_to_python_path(path: Path):
+    """
+    Helper function - context adding path to python path and then remove it
+
+    Args
+        path: path of file or folder to add to python path, in case of file adds the containing folder
+    Returns
+    """
+    try:
+        folder = str(path.parent) if path.is_file() else str(path)
+        sys.path.append(folder)
+        yield
+    finally:
+        sys.path.remove(folder)