qwak-sdk 0.5.102__py3-none-any.whl

qwak_sdk/commands/workspaces/_logic/workspace_validations.py

@@ -0,0 +1,41 @@
+from typing import Optional
+
+from qwak.clients.instance_template.client import InstanceTemplateManagementClient
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+from qwak.exceptions import QwakException
+from qwak.inner.instance_template.verify_template_id import verify_template_id
+
+WORKSPACE_NAME_EMPTY_VALIDATION_MSG = "Workspace name cannot be empty"
+WORKSPACE_NAME_LENGTH_VALIDATION_MSG = (
+    "Workspace name must be between 3 and 254 characters."
+)
+MIN_WORKSPACE_NAME_LENGTH = 3
+MAX_WORKSPACE_NAME_LENGTH = 254
+
+
+def _validate_workspace_name(name: str):
+    if (name is None) or (len(name) == 0):
+        raise QwakException(WORKSPACE_NAME_EMPTY_VALIDATION_MSG)
+    if (len(name) < MIN_WORKSPACE_NAME_LENGTH) or (
+        len(name) > MAX_WORKSPACE_NAME_LENGTH
+    ):
+        raise QwakException(WORKSPACE_NAME_LENGTH_VALIDATION_MSG)
+
+
+def _verify_image_id(image_id: str, workspace_manager_client: WorkspaceManagerClient):
+    workspace_images = workspace_manager_client.get_workspace_images().workspace_images
+    image_ids = [image.id for image in workspace_images]
+    if image_id not in image_ids:
+        raise QwakException(
+            f"Image {image_id} is not supported. Supported images are: {image_ids}"
+        )
+
+
+def _verify_instance(instance: str):
+    instance_template_client = InstanceTemplateManagementClient()
+    verify_template_id(instance, instance_template_client)
+
+
+def validate_id_or_name(workspace_id: Optional[str], workspace_name: Optional[str]):
+    if (not workspace_id) and (not workspace_name):
+        raise QwakException("Workspace id or name must be provided")

qwak_sdk/commands/workspaces/config/workspace_config.py

@@ -0,0 +1,35 @@
+from dataclasses import dataclass, field
+from typing import List
+
+from qwak.inner.tool.run_config import (
+    ConfigCliMap,
+    QwakConfigBase,
+    YamlConfigMixin,
+    validate_string,
+)
+
+WORKSPACE_CLI_CONFIG_MAPPING: List[ConfigCliMap] = [
+    ConfigCliMap("workspace_id", "workspace.workspace_id", validate_string, False),
+    ConfigCliMap("name", "workspace.name", validate_string, False),
+    ConfigCliMap("instance", "workspace.instance", validate_string, False),
+    ConfigCliMap("image", "workspace.image", validate_string, False),
+]
+
+
+@dataclass
+class WorkspaceConfig(YamlConfigMixin, QwakConfigBase):
+    def _post_merge_cli(self):
+        pass
+
+    @property
+    def _config_mapping(self) -> List[ConfigCliMap]:
+        return WORKSPACE_CLI_CONFIG_MAPPING
+
+    @dataclass
+    class Workspace:
+        workspace_id: str = field(default_factory=str)
+        name: str = field(default_factory=str)
+        instance: str = field(default_factory=str)
+        image: str = field(default_factory=str)
+
+    workspace: Workspace = field(default_factory=Workspace)

qwak_sdk/commands/workspaces/create/_logic.py

@@ -0,0 +1,54 @@
+from _qwak_proto.qwak.instance_template.instance_template_pb2 import InstanceType
+from _qwak_proto.qwak.workspace.workspace_pb2 import DefaultWorkspaceDetails
+from qwak.clients.instance_template.client import InstanceTemplateManagementClient
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+
+from qwak_sdk.commands.workspaces._logic.workspace_validations import (
+    _validate_workspace_name,
+    _verify_image_id,
+    _verify_instance,
+)
+from qwak_sdk.commands.workspaces.config.workspace_config import WorkspaceConfig
+
+
+def _create_workspace(config: WorkspaceConfig):
+    """
+    Creating a new workspace
+
+    Args:
+        config: The workspace configuration
+
+    """
+    print(f"Creating a new workspace with the name {config.workspace.name}")
+    workspace_manager_client = WorkspaceManagerClient()
+    default_details: DefaultWorkspaceDetails = (
+        workspace_manager_client.get_default_workspace_details()
+    )
+
+    _validate_workspace_name(config.workspace.name)
+    if config.workspace.instance:
+        _verify_instance(config.workspace.instance)
+    else:
+        config.workspace.instance = (
+            default_details.cpu_compute_resources.template_spec.template_id
+        )
+
+    if config.workspace.image:
+        _verify_image_id(config.workspace.image, workspace_manager_client)
+    else:
+        instance_spec = InstanceTemplateManagementClient().get_instance_template(
+            config.workspace.instance
+        )
+        config.workspace.image = (
+            default_details.cpu_image_id
+            if instance_spec.instance_type == InstanceType.INSTANCE_TYPE_CPU
+            else default_details.gpu_image_id
+        )
+
+    response = workspace_manager_client.create_workspace(
+        config.workspace.name, config.workspace.image, config.workspace.instance
+    )
+
+    print(
+        f"Workspace {config.workspace.name} was created successfully with id: {response.workspace_id}"
+    )

qwak_sdk/commands/workspaces/create/ui.py

@@ -0,0 +1,48 @@
+from typing import Optional
+
+import click
+
+from qwak_sdk.commands.workspaces.config.workspace_config import WorkspaceConfig
+from qwak_sdk.commands.workspaces.create._logic import _create_workspace
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.config_handler import config_handler
+
+
+@click.command("create", cls=QwakCommand)
+@click.option(
+    "--name",
+    required=False,
+    metavar="NAME",
+    help="The name of the requested workspace",
+)
+@click.option(
+    "--instance",
+    required=False,
+    metavar="INSTANCE",
+    help="The instance id of the requested template",
+)
+@click.option(
+    "--image",
+    required=False,
+    metavar="IMAGE",
+    help="The image for the requested workspace",
+)
+@click.option(
+    "--out-conf",
+    help="Extract workspace conf from commands arguments, the commands will not run it wil only output valid yaml ",
+    default=False,
+    is_flag=True,
+)
+@click.option(
+    "--from-file",
+    required=False,
+    help="Create by run_config file, Command arguments will overwrite any run_config.",
+)
+def create_workspace(from_file: Optional[str], out_conf: bool, **kwargs):
+    config: WorkspaceConfig = config_handler(
+        config=WorkspaceConfig,
+        from_file=from_file,
+        **kwargs,
+        out_conf=out_conf,
+    )
+    _create_workspace(config)

qwak_sdk/commands/workspaces/delete/_logic.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+
+from qwak_sdk.commands.workspaces._logic.tools import get_workspace_id_by_name
+from qwak_sdk.commands.workspaces._logic.workspace_validations import (
+    validate_id_or_name,
+)
+
+
+def _delete_workspace(workspace_id: Optional[str], workspace_name: Optional[str]):
+    """
+    Deleting workspace
+    Args:
+    workspace_id: The id of the workspace to delete
+    """
+    validate_id_or_name(workspace_id=workspace_id, workspace_name=workspace_name)
+    workspace_manager_client = WorkspaceManagerClient()
+    if workspace_id:
+        print(f"Deleting an existing workspace with id {workspace_id}")
+        workspace_manager_client.delete_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_id} was deleted successfully")
+    if workspace_name:
+        print(f"Deleting an existing workspace with name {workspace_name}")
+        workspace_id = get_workspace_id_by_name(
+            workspace_name=workspace_name,
+            workspace_manager_client=workspace_manager_client,
+        )
+        workspace_manager_client.delete_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_name} was deleted successfully")

qwak_sdk/commands/workspaces/delete/ui.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import click
+
+from qwak_sdk.commands.workspaces.delete._logic import _delete_workspace
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("delete", cls=QwakCommand)
+@click.option(
+    "--workspace-id",
+    required=False,
+    metavar="WORKSPACE-ID",
+    help="The id of the workspace",
+)
+@click.option(
+    "--name",
+    required=False,
+    metavar="WORKSPACE-NAME",
+    help="The name of the workspace",
+)
+def delete_workspace(workspace_id: Optional[str], name: Optional[str], **kwargs):
+    _delete_workspace(workspace_id=workspace_id, workspace_name=name)

qwak_sdk/commands/workspaces/start/_logic.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+
+from qwak_sdk.commands.workspaces._logic.tools import get_workspace_id_by_name
+from qwak_sdk.commands.workspaces._logic.workspace_validations import (
+    validate_id_or_name,
+)
+
+
+def _start_workspace(workspace_id: Optional[str], workspace_name=Optional[str]):
+    """
+    Deploying an existing workspace
+    Args:
+    workspace_id: The id of the workspace to deploy
+    """
+    validate_id_or_name(workspace_id=workspace_id, workspace_name=workspace_name)
+    workspace_manager_client = WorkspaceManagerClient()
+    if workspace_id:
+        print(f"Starting an existing workspace with id {workspace_id}")
+        workspace_manager_client.deploy_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_id} started successfully")
+    if workspace_name:
+        print(f"Starting an existing workspace with name {workspace_name}")
+        workspace_id = get_workspace_id_by_name(
+            workspace_name=workspace_name,
+            workspace_manager_client=workspace_manager_client,
+        )
+        workspace_manager_client.deploy_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_name} started successfully")

qwak_sdk/commands/workspaces/start/ui.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import click
+
+from qwak_sdk.commands.workspaces.start._logic import _start_workspace
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("start", cls=QwakCommand)
+@click.option(
+    "--workspace-id",
+    required=False,
+    metavar="WORKSPACE-ID",
+    help="The id of the workspace",
+)
+@click.option(
+    "--name",
+    required=False,
+    metavar="WORKSPACE-NAME",
+    help="The name of the workspace",
+)
+def start_workspace(workspace_id: Optional[str], name: Optional[str], **kwargs):
+    _start_workspace(workspace_id=workspace_id, workspace_name=name)

qwak_sdk/commands/workspaces/stop/_logic.py

@@ -0,0 +1,30 @@
+from typing import Optional
+
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+
+from qwak_sdk.commands.workspaces._logic.tools import get_workspace_id_by_name
+from qwak_sdk.commands.workspaces._logic.workspace_validations import (
+    validate_id_or_name,
+)
+
+
+def _stop_workspace(workspace_id: Optional[str], workspace_name: Optional[str]):
+    """
+    Stop an existing workspace
+    Args:
+    workspace_id: The id of the workspace to deploy
+    """
+    validate_id_or_name(workspace_id=workspace_id, workspace_name=workspace_name)
+    workspace_manager_client = WorkspaceManagerClient()
+    if workspace_id:
+        print(f"Stopping an existing workspace with id {workspace_id}")
+        workspace_manager_client.undeploy_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_id} was stopped successfully")
+    if workspace_name:
+        print(f"Stopping an existing workspace with name {workspace_name}")
+        workspace_id = get_workspace_id_by_name(
+            workspace_name=workspace_name,
+            workspace_manager_client=workspace_manager_client,
+        )
+        workspace_manager_client.undeploy_workspace(workspace_id=workspace_id)
+        print(f"Workspace {workspace_name} was stopped successfully")

qwak_sdk/commands/workspaces/stop/ui.py

@@ -0,0 +1,23 @@
+from typing import Optional
+
+import click
+
+from qwak_sdk.commands.workspaces.stop._logic import _stop_workspace
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+
+
+@click.command("stop", cls=QwakCommand)
+@click.option(
+    "--workspace-id",
+    required=False,
+    metavar="WORKSPACE-ID",
+    help="The id of the workspace",
+)
+@click.option(
+    "--name",
+    required=False,
+    metavar="WORKSPACE-NAME",
+    help="The name of the workspace",
+)
+def stop_workspace(workspace_id: Optional[str], name: Optional[str], **kwargs):
+    _stop_workspace(workspace_id=workspace_id, workspace_name=name)

qwak_sdk/commands/workspaces/update/_logic.py

@@ -0,0 +1,82 @@
+from qwak.clients.workspace_manager import WorkspaceManagerClient
+
+from qwak_sdk.commands.workspaces._logic.tools import get_workspace_by_name
+from qwak_sdk.commands.workspaces._logic.workspace_validations import (
+    _validate_workspace_name,
+    _verify_image_id,
+    _verify_instance,
+    validate_id_or_name,
+)
+from qwak_sdk.commands.workspaces.config.workspace_config import WorkspaceConfig
+
+
+def _update_workspace(config: WorkspaceConfig):
+    """
+    Updating a workspace
+
+    Args:
+        config: The workspace configuration
+
+    """
+    validate_id_or_name(
+        workspace_id=config.workspace.workspace_id, workspace_name=config.workspace.name
+    )
+    workspace_manager_client = WorkspaceManagerClient()
+    if config.workspace.workspace_id:
+        print(
+            f"Updating a workspace with the workspace id {config.workspace.workspace_id}"
+        )
+        current_workspace = workspace_manager_client.get_workspace_by_id(
+            workspace_id=config.workspace.workspace_id
+        ).workspace
+    else:
+        print(f"Updating a workspace with the workspace name {config.workspace.name}")
+        current_workspace = get_workspace_by_name(
+            workspace_name=config.workspace.name,
+            workspace_manager_client=workspace_manager_client,
+        )
+
+    workspace_id = current_workspace.workspace_id
+    workspace_name = config.workspace.name
+    image_id = config.workspace.image
+    instance = config.workspace.instance
+
+    if _is_not_empty_and_not_none(workspace_name):
+        _validate_workspace_name(workspace_name)
+
+    if _is_not_empty_and_not_none(image_id):
+        _verify_image_id(image_id, workspace_manager_client)
+
+    if _is_not_empty_and_not_none(instance):
+        _verify_instance(instance)
+
+    name = (
+        workspace_name
+        if _is_not_empty_and_not_none(workspace_name)
+        else current_workspace.workspace_name
+    )
+    image_id = (
+        image_id if _is_not_empty_and_not_none(image_id) else current_workspace.image_id
+    )
+
+    instance = (
+        instance
+        if _is_not_empty_and_not_none(instance)
+        else current_workspace.client_pod_compute_resources.template_spec.template_id
+    )
+
+    workspace_manager_client.update_workspace(
+        workspace_id=workspace_id,
+        image_id=image_id,
+        template_id=instance,
+        workspace_name=name,
+    )
+
+    if config.workspace.workspace_id:
+        print(f"Workspace {workspace_id} was updated successfully")
+    else:
+        print(f"Workspace {workspace_name} was updated successfully")
+
+
+def _is_not_empty_and_not_none(value: str) -> bool:
+    return value is not None and value != ""

qwak_sdk/commands/workspaces/update/ui.py

@@ -0,0 +1,57 @@
+from typing import Optional
+
+import click
+
+from qwak_sdk.commands.workspaces.config.workspace_config import WorkspaceConfig
+from qwak_sdk.commands.workspaces.update._logic import _update_workspace
+from qwak_sdk.inner.tools.cli_tools import QwakCommand
+from qwak_sdk.inner.tools.config_handler import config_handler
+
+
+@click.command("update", cls=QwakCommand)
+@click.option(
+    "--workspace-id",
+    required=False,
+    metavar="WORKSPACE-ID",
+    help="The id of the workspace",
+)
+@click.option(
+    "--name",
+    metavar="NAME",
+    required=False,
+    default=None,
+    help="The name of the requested workspace",
+)
+@click.option(
+    "--instance",
+    metavar="INSTANCE",
+    required=False,
+    default=None,
+    help="The instance id of the requested template",
+)
+@click.option(
+    "--image",
+    required=False,
+    metavar="IMAGE",
+    default=None,
+    help="The image template for the requested workspace",
+)
+@click.option(
+    "--out-conf",
+    help="Extract workspace conf from commands arguments, the commands will not run it wil only output valid yaml ",
+    default=False,
+    is_flag=True,
+)
+@click.option(
+    "--from-file",
+    required=False,
+    help="Create by run_config file, Command arguments will overwrite any run_config.",
+)
+def update_workspace(from_file: Optional[str], out_conf: bool, **kwargs):
+    config: WorkspaceConfig = config_handler(
+        config=WorkspaceConfig,
+        from_file=from_file,
+        **kwargs,
+        out_conf=out_conf,
+    )
+    _update_workspace(config)

qwak_sdk/commands/workspaces/workspaces_commands_group.py

@@ -0,0 +1,23 @@
+import click
+
+from qwak_sdk.commands.workspaces.create.ui import create_workspace
+from qwak_sdk.commands.workspaces.delete.ui import delete_workspace
+from qwak_sdk.commands.workspaces.start.ui import start_workspace
+from qwak_sdk.commands.workspaces.stop.ui import stop_workspace
+from qwak_sdk.commands.workspaces.update.ui import update_workspace
+
+
+@click.group(
+    "workspaces",
+    help="Commands for interacting with workspaces",
+)
+def workspaces_commands_group():
+    # Click commands group injection
+    pass
+
+
+workspaces_commands_group.add_command(create_workspace)
+workspaces_commands_group.add_command(update_workspace)
+workspaces_commands_group.add_command(start_workspace)
+workspaces_commands_group.add_command(delete_workspace)
+workspaces_commands_group.add_command(stop_workspace)

qwak_sdk/exceptions/__init__.py

@@ -0,0 +1,11 @@
+from qwak.exceptions import QwakGeneralBuildException, QwakSuggestionException
+
+from .qwak_command_exception import QwakCommandException
+from .qwak_resource_not_found import QwakResourceNotFound
+
+__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.exceptions import QwakSuggestionException
+
+
+class QwakDeployNewBuildFailedException(QwakSuggestionException):
+    pass

qwak_sdk/exceptions/qwak_resource_not_found.py

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

qwak_sdk/inner/file_registry.py

@@ -0,0 +1,98 @@
+import importlib.util
+import os
+import sys
+from contextlib import contextmanager
+from pathlib import Path
+from typing import List, Tuple
+
+from yaspin.core import Yaspin
+
+
+def list_qwak_python_files(path: Path, sp: Yaspin) -> List[Tuple[str, str]]:
+    """
+    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)