qwak-sdk 0.5.102__py3-none-any.whl

qwak_sdk/commands/models/build/_logic/client_logs/cli_phase_run_handler.py

@@ -0,0 +1,123 @@
+from contextlib import contextmanager
+from logging import Logger
+from pathlib import Path
+
+from qwak.inner.build_logic.interface.build_phase import BuildPhase
+from qwak.inner.build_logic.interface.phase_run_handler import PhaseRunHandler
+from qwak.inner.build_logic.phases.phases_pipeline import PhasesPipeline
+from yaspin import yaspin
+
+from qwak_sdk.tools.colors import Color
+from .cli_trigger_build_logger import CliTriggerBuildLogger
+from .messages import (
+    FAILED_CONTACT_QWAK_SUPPORT,
+)
+from .utils import zip_logs
+
+
+class CLIPhaseRunHandler(PhaseRunHandler):
+    BUILD_IN_PROGRESS_FORMAT = "Build phase in progress: {}"
+    BUILD_FINISHED_FORMAT = "Phase successfully finished: {} after {} seconds"
+    KEYBOARD_INTERRUPT_FORMAT = "\n{color}Stopping Qwak build (ctrl-c)"
+    BUILD_FAILURE_FORMAT = "Build phase failed: {} after {} seconds"
+    PIPELINE_ERROR = "\n{color}{ex}"
+    SPINNER_FINISH = "✅"
+    SPINNER_FAIL = "💥"
+    SPINNER_OK = "‼️"
+
+    def __init__(self, python_logger: Logger, log_path: Path, verbose: int, json_logs: bool):
+        self.sp = None
+        self.build_logger = None
+        self.log_path = str(log_path)
+        self.python_logger = python_logger
+        self.json_logs = json_logs
+        self.verbose = verbose
+
+    @contextmanager
+    def handle_current_phase(self, phase: PhasesPipeline):
+        build_logger = CliTriggerBuildLogger(
+            self.python_logger,
+            prefix="" if self.json_logs else phase.build_phase.description,
+            build_phase=phase.build_phase,
+        )
+        show = (self.verbose == 0 and not self.json_logs)
+        text = phase.build_phase.description
+        if show:
+            with yaspin(text=text, color="blue", timer=True).bold as sp:
+                self.sp = sp
+                build_logger.set_spinner(sp)
+                self.build_logger = build_logger
+                yield
+        else:
+            self.build_logger = build_logger
+            yield
+
+    def handle_phase_in_progress(self, build_phase: BuildPhase):
+        logger = self.build_logger or self.python_logger
+        logger.debug(
+            self.BUILD_IN_PROGRESS_FORMAT.format(build_phase.name)
+        )
+
+    def handle_phase_finished_successfully(
+        self, build_phase: BuildPhase, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.ok(self.SPINNER_FINISH)
+
+        logger = self.build_logger or self.python_logger
+        logger.debug(
+            self.BUILD_FINISHED_FORMAT.format(build_phase.name, duration_in_seconds))
+
+    def _report_failure(self, build_phase: BuildPhase, duration_in_seconds: int):
+        logger = self.build_logger or self.python_logger
+        logger.debug(
+            self.BUILD_FAILURE_FORMAT.format(build_phase.name, duration_in_seconds))
+
+    def handle_contact_support_error(
+        self, build_id: str, build_phase: BuildPhase, ex: BaseException, duration_in_seconds: int
+    ):
+        print(f"\n{ex}\n{FAILED_CONTACT_QWAK_SUPPORT.format(build_id=build_id, log_file=Path(self.log_path).parent / build_id)}")
+        zip_logs(log_path=self.log_path, build_id=build_id)
+        self._report_failure(build_phase, duration_in_seconds)
+        exit(1)
+
+    def handle_remote_build_error(
+        self, build_id: str, build_phase: BuildPhase, ex: BaseException, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.fail(self.SPINNER_FAIL)
+            print(self.PIPELINE_ERROR.format(color=Color.RED, ex=ex))
+        else:
+            print(f"\n{ex}")
+        self._report_failure(build_phase, duration_in_seconds)
+        exit(1)
+
+    def handle_keyboard_interrupt(
+        self, build_id: str, build_phase: BuildPhase, duration_in_seconds: int
+    ):
+        print(self.KEYBOARD_INTERRUPT_FORMAT.format(color=Color.RED))
+        zip_logs(log_path=self.log_path, build_id=build_id)
+        self._report_failure(build_phase, duration_in_seconds)
+        exit(1)
+
+    def handle_pipeline_exception(
+        self, build_id: str, build_phase: BuildPhase, ex: BaseException, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.fail("💥")
+            print(f"\n{Color.RED}{ex}")
+        zip_logs(
+            log_path=self.log_path,
+            build_id=build_id,
+        )
+        self._report_failure(build_phase, duration_in_seconds)
+        exit(1)
+
+    def handle_pipeline_quiet_exception(
+        self, build_id: str, build_phase: BuildPhase, ex: BaseException, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.ok(self.SPINNER_OK)
+            print(self.PIPELINE_ERROR.format(color=Color.RED, ex=ex))
+        self._report_failure(build_phase, duration_in_seconds)
+        exit(1)

qwak_sdk/commands/models/build/_logic/client_logs/cli_trigger_build_logger.py

@@ -0,0 +1,19 @@
+from logging import Logger
+
+from qwak.inner.build_logic.build_loggers.trigger_build_logger import TriggerBuildLogger
+from qwak.inner.build_logic.interface.build_phase import BuildPhase
+from yaspin.core import Yaspin
+
+
+class CliTriggerBuildLogger(TriggerBuildLogger):
+    def __init__(self, logger: Logger, prefix: str, build_phase: BuildPhase, verbose: int = 0,
+                 json_logs: bool = False) -> None:
+        super().__init__(logger, prefix, build_phase, verbose, json_logs)
+        self.spinner = None
+
+    def set_spinner(self, spinner: Yaspin):
+        self.spinner = spinner
+
+    def spinner_text(self, line: str) -> None:
+        if self.spinner:
+            self.spinner.text = f"{self.prefix}{line}"

qwak_sdk/commands/models/build/_logic/client_logs/logger.py

@@ -0,0 +1,88 @@
+import contextlib
+import logging
+import os
+import platform
+import shutil
+import sys
+import uuid
+from pathlib import Path
+
+from qwak.inner.build_config.build_config_v1 import BuildConfigV1
+from qwak.inner.build_logic.constants.host_resource import HOST_QWAK_HIDDEN_FOLDER
+
+from qwak_sdk import __version__ as qwak_sdk_version
+from qwak_sdk.inner.tools.logger import setup_qwak_logger
+from qwak_sdk.inner.tools.logger.logger import (
+    BUILD_LOCAL_FILE_HANDLER_NAME,
+    BUILD_LOCAL_LOGGER_NAME,
+    CONSOLE_HANDLER_NAME,
+    REMOTE_CONSOLE_HANDLER_NAME,
+    REMOTE_LOGGER_NAME,
+    VERBOSITY_LEVEL_MAPPING,
+    get_qwak_logger,
+    non_qwak_logger_enabled,
+    set_file_handler_log_file,
+    set_handler_verbosity,
+)
+
+BUILDS_LOGS = HOST_QWAK_HIDDEN_FOLDER / "logs" / "build"
+BUILD_LOG_NAME = "build.log"
+MAX_LOGS_NUMBER = 15
+DEBUG_LEVEL = 2
+
+
+@contextlib.contextmanager
+def get_build_logger(config: BuildConfigV1, json_logs: bool):
+    log_path = BUILDS_LOGS / config.build_properties.model_id / str(uuid.uuid4())[:4]
+    log_path.mkdir(parents=True, exist_ok=True)
+    try:
+        (log_path / "build_config.yml").write_text(config.to_yaml())
+        log_system_information(log_path)
+
+        log_file = log_path / BUILD_LOG_NAME
+        setup_qwak_logger()
+        yield setup_logger(
+            log_file=log_file, verbosity_level=config.verbose, json_logs=json_logs
+        ), log_path
+    finally:
+        # Cleanup - Save only x last zips
+        logs_zip_sorted_by_data = sorted(
+            BUILDS_LOGS.rglob("**/*"), key=os.path.getmtime
+        )[:-MAX_LOGS_NUMBER]
+        path: Path
+        for path in logs_zip_sorted_by_data:
+            if path.is_file():
+                os.remove(path)
+            elif path.is_dir():
+                shutil.rmtree(path, ignore_errors=True)
+
+
+def setup_logger(
+    log_file: Path, verbosity_level: int, json_logs: bool
+) -> logging.Logger:
+    # Init logger
+    fallback_logger_name = (
+        BUILD_LOCAL_LOGGER_NAME if not json_logs else REMOTE_LOGGER_NAME
+    )
+    logger = get_qwak_logger(fallback_logger_name=fallback_logger_name)
+
+    if not non_qwak_logger_enabled():
+        if logger.name == BUILD_LOCAL_LOGGER_NAME:
+            set_file_handler_log_file(logger, BUILD_LOCAL_FILE_HANDLER_NAME, log_file)
+            set_handler_verbosity(
+                logger, CONSOLE_HANDLER_NAME, VERBOSITY_LEVEL_MAPPING[verbosity_level]
+            )
+        elif logger.name == REMOTE_LOGGER_NAME and json_logs:
+            set_handler_verbosity(
+                logger,
+                REMOTE_CONSOLE_HANDLER_NAME,
+                VERBOSITY_LEVEL_MAPPING[DEBUG_LEVEL],
+            )
+
+    return logger
+
+
+def log_system_information(destination: Path):
+    (destination / "python_version").write_text(sys.version)
+    (destination / "qwak_sdk_version").write_text(qwak_sdk_version)
+    (destination / "os_detail").write_text(platform.platform())

qwak_sdk/commands/models/build/_logic/client_logs/messages.py

@@ -0,0 +1,36 @@
+BUILD_LOGS_URL = (
+    "{base_url}/models/{model_id}/build/{build_id}"
+)
+
+SUCCESS_MSG_REMOTE = """
+Build ID \033[4m{build_id}\033[0m triggered remotely
+
+########### Follow build logs in the CLI
+qwak models builds logs -b {build_id} --follow
+
+########### Follow build logs in the platform
+{base_url}/models/{model_id}/build/{build_id}
+"""
+
+SUCCESS_MSG_REMOTE_WITH_DEPLOY = """
+Build ID \033[4m{build_id}\033[0m finished successfully and deployed
+
+########### View the model using platform
+{base_url}/models/{model_id}
+"""
+
+FAILED_CONTACT_QWAK_SUPPORT = """
+Build ID \033[4m{build_id}\033[0m failed!!
+You can share the logs from \033[4m{log_file}.zip\033[0m with the support team.
+"""
+
+FAILED_REMOTE_BUILD_SUGGESTION = """
+Your build failed. Check the failure reason in the platform:
+{base_url}/models/{model_id}/build/{build_id}
+"""
+
+FAILED_DEPLOY_BUILD_SUGGESTION = """
+Deploying the build failed. Check the failure reason in the platform:
+{base_url}/models/{model_id}?tabId=1
+Try and redeploy this build either from the platform or the CLI
+"""

qwak_sdk/commands/models/build/_logic/client_logs/spinner.py

@@ -0,0 +1,14 @@
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+from yaspin import yaspin
+from yaspin.core import Yaspin
+
+
+@contextmanager
+def spinner(text: Optional[str], show: bool) -> Generator[Yaspin, None, None]:
+    if show:
+        with yaspin(text=text, color="blue", timer=True).bold as sp:
+            yield sp
+    else:
+        yield

qwak_sdk/commands/models/build/_logic/client_logs/trigger_build_logger.py

@@ -0,0 +1,54 @@
+import logging
+from logging import Logger
+
+from qwak.inner.build_logic.interface.build_logger_interface import BuildLogger
+from qwak.inner.build_logic.interface.build_phase import BuildPhase
+from yaspin.core import Yaspin
+
+
+PREFIX_FORMAT = "{prefix} - "
+EXCEPTION_FORMAT = """Message: {line}
+Exception: {e}
+"""
+
+
+class TriggerBuildLogger(BuildLogger):
+    def __init__(
+        self, logger: Logger, prefix: str, build_phase: BuildPhase, verbose: int = 0, json_logs: bool = False,
+    ) -> None:
+        self.logger = logging.LoggerAdapter(
+            logger,
+            {
+                "phase": build_phase.description,
+                "phase_id": build_phase.phase_id,
+            },
+        )
+        self.prefix = PREFIX_FORMAT.format(prefix=prefix) if prefix else ""
+        self.spinner = None
+        self.verbose = verbose
+        self.json_logs = json_logs
+
+    def set_spinner(self, spinner: Yaspin):
+        self.spinner = spinner
+
+    def exception(self, line: str, e: BaseException) -> None:
+        self.logger.error(
+            EXCEPTION_FORMAT.format(line=line, e=e),
+            exc_info=False,
+        )
+
+    def error(self, line: str) -> None:
+        self.logger.error(f"{self.prefix}{line}")
+
+    def warning(self, line: str) -> None:
+        self.logger.warning(f"{self.prefix}{line}")
+
+    def info(self, line: str) -> None:
+        self.logger.info(f"{self.prefix}{line}")
+
+    def debug(self, line: str) -> None:
+        self.logger.debug(f"{self.prefix}{line}")
+
+    def spinner_text(self, line: str) -> None:
+        if self.spinner:
+            self.spinner.text = f"{self.prefix}{line}"

qwak_sdk/commands/models/build/_logic/client_logs/utils.py

@@ -0,0 +1,12 @@
+import shutil
+from pathlib import Path
+
+
+def zip_logs(log_path: str, build_id: str):
+    if build_id:
+        shutil.make_archive(
+            base_name=str(Path(log_path).parent / build_id),
+            format="zip",
+            root_dir=log_path,
+        )
+        shutil.rmtree(log_path, ignore_errors=True)

qwak_sdk/commands/models/build/_logic/phase/a_fetch_model_code/__init__.py

@@ -0,0 +1,20 @@
+from typing import List
+
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak.inner.build_logic.phases.phase_010_fetch_model.fetch_model_step import FetchModelStep
+from qwak.inner.build_logic.phases.phase_010_fetch_model.post_fetch_validation_step import PostFetchValidationStep
+from qwak.inner.build_logic.phases.phase_010_fetch_model.pre_fetch_validation_step import PreFetchValidationStep
+
+from qwak_sdk.commands.models.build._logic.phase.a_fetch_model_code.get_sdk_version_step import SdkVersionStep
+from qwak_sdk.commands.models.build._logic.util.step_decorator import add_decorator_to_steps
+
+
+def get_fetch_model_code_steps() -> List[Step]:
+    phase_steps = [
+        SdkVersionStep(),
+        PreFetchValidationStep(),
+        FetchModelStep(),
+        PostFetchValidationStep(),
+    ]
+
+    return add_decorator_to_steps(phase_steps)

qwak_sdk/commands/models/build/_logic/phase/a_fetch_model_code/get_sdk_version_step.py

@@ -0,0 +1,14 @@
+from qwak.inner.build_logic.interface.step_inteface import Step
+
+from qwak_sdk import __version__ as qwak_sdk_version
+
+
+class SdkVersionStep(Step):
+    def description(self) -> str:
+        return "Getting SDK Version"
+
+    def execute(self) -> None:
+        self.build_logger.debug(
+            "Getting sdk version"
+        )
+        self.context.qwak_sdk_version = qwak_sdk_version

qwak_sdk/commands/models/build/_logic/phase/b_remote_register_qwak_build/__init__.py

@@ -0,0 +1,16 @@
+from qwak.inner.build_logic.phases.phase_020_remote_register_qwak_build.cleanup_step import CleanupStep
+from qwak.inner.build_logic.phases.phase_020_remote_register_qwak_build.start_remote_build_step import \
+    StartRemoteBuildStep
+from qwak.inner.build_logic.phases.phase_020_remote_register_qwak_build.upload_step import UploadStep
+
+from ...util.step_decorator import add_decorator_to_steps
+
+
+def get_remote_register_qwak_build_steps():
+    phase_steps = [
+        UploadStep(),
+        StartRemoteBuildStep(),
+        CleanupStep(),
+    ]
+
+    return add_decorator_to_steps(phase_steps)

qwak_sdk/commands/models/build/_logic/phase/c_deploy/__init__.py

@@ -0,0 +1,6 @@
+from .build_polling_status import BuildPollingStatusStep
+from .deploy_build import DeployBuildStep
+
+
+def get_deploy_steps():
+    return [BuildPollingStatusStep(), DeployBuildStep()]

qwak_sdk/commands/models/build/_logic/phase/c_deploy/build_polling_status.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import time
+
+from _qwak_proto.qwak.build.v1.build_api_pb2 import GetBuildResponse
+from _qwak_proto.qwak.build.v1.build_pb2 import BuildStatus
+
+from qwak_sdk.commands.models.build._logic.client_logs.messages import (
+    FAILED_REMOTE_BUILD_SUGGESTION,
+)
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak.exceptions import QwakRemoteBuildFailedException
+
+
+class BuildPollingStatusStep(Step):
+    FINITE_BUILD_STATUSES = {
+        BuildStatus.REMOTE_BUILD_CANCELLED,
+        BuildStatus.REMOTE_BUILD_TIMED_OUT,
+        BuildStatus.FAILED,
+        BuildStatus.SUCCESSFUL,
+    }
+    SLEEP_BETWEEN_STATUS_CHECK = 10
+    REMOTE_BUILD_FAILURE_EXCEPTION_FORMAT = "Your build failed with status {status}"
+
+    def description(self) -> str:
+        return "Polling on Build Status"
+
+    def execute(self) -> None:
+        self.build_logger.info("Waiting for build to finish")
+        status = self.wait_for_finite_build_status()
+        if status != BuildStatus.SUCCESSFUL:
+            raise QwakRemoteBuildFailedException(
+                message=self.REMOTE_BUILD_FAILURE_EXCEPTION_FORMAT.format(
+                    status=BuildStatus.Name(status)
+                ),
+                suggestion=FAILED_REMOTE_BUILD_SUGGESTION.format(
+                    base_url=self.context.platform_url,
+                    build_id=self.context.build_id,
+                    model_id=self.context.model_id,
+                    project_uuid=self.context.project_uuid,
+                ),
+            )
+        self.build_logger.info("Your build finished successfully")
+
+    def wait_for_finite_build_status(self) -> BuildStatus:
+        self.build_logger.spinner_text(line="Waiting for build to finish")
+        while True:
+            result: GetBuildResponse = (
+                self.context.client_builds_orchestrator.get_build(self.context.build_id)
+            )
+            status: BuildStatus = result.build.build_status
+            if status in self.FINITE_BUILD_STATUSES:
+                return status
+            self.build_logger.debug(f"Build status is currently {BuildStatus.Name(status)}")
+            time.sleep(self.SLEEP_BETWEEN_STATUS_CHECK)

qwak_sdk/commands/models/build/_logic/phase/c_deploy/deploy_build.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import List
+
+from _qwak_proto.qwak.instance_template.instance_template_pb2 import (
+    InstanceTemplateSpec,
+    InstanceType,
+)
+
+from qwak_sdk.commands.models.build._logic.client_logs.messages import (
+    FAILED_DEPLOY_BUILD_SUGGESTION,
+)
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak_sdk.commands.models.deployments.deploy.realtime.ui import deploy_realtime
+from qwak_sdk.exceptions.qwak_deploy_new_build_failed import (
+    QwakDeployNewBuildFailedException,
+)
+
+
+class DeployBuildStep(Step):
+    DEPLOY_FAILURE_EXCEPTION_MESSAGE = "Deploying the build failed due to {e}"
+
+    def description(self) -> str:
+        return "Deploying Build"
+
+    def execute(self) -> None:
+        self.build_logger.info(f"Deploying build {self.context.build_id}")
+        try:
+            if self.config.deployment_instance:
+                template_id = self.config.deployment_instance
+            else:
+                template_id = self.get_smallest_deployment_template_id()
+            deploy_config = {
+                "build_id": self.context.build_id,
+                "model_id": self.context.model_id,
+                "instance": template_id,
+            }
+            deploy_realtime(from_file=None, out_conf=False, sync=False, **deploy_config)
+            self.build_logger.info(f"Finished deploying build {self.context.build_id}")
+        except Exception as e:
+            raise QwakDeployNewBuildFailedException(
+                message=self.DEPLOY_FAILURE_EXCEPTION_MESSAGE.format(e=e),
+                suggestion=FAILED_DEPLOY_BUILD_SUGGESTION.format(
+                    base_url=self.context.platform_url,
+                    build_id=self.context.build_id,
+                    model_id=self.context.model_id,
+                    project_uuid=self.context.project_uuid,
+                ),
+            )
+
+    def get_smallest_deployment_template_id(self):
+        instances: List[
+            InstanceTemplateSpec
+        ] = self.context.client_instance_template.list_instance_templates()
+        return list(
+            filter(
+                lambda template: template.order == 1
+                and template.instance_type == InstanceType.INSTANCE_TYPE_CPU,
+                instances,
+            )
+        )[0].id

qwak_sdk/commands/models/build/_logic/util/protobuf_factory.py

@@ -0,0 +1,45 @@
+from qwak.exceptions import QwakException
+
+
+def protobuf_factory(
+    protobuf_class, exclude_fields=None, include_only=None, mapping=None
+):
+    def get_final_field_names(cls):
+        fields = dict(cls.__dataclass_fields__)
+        all_field_names = set(fields.keys())
+        excluded_fields = set(exclude_fields) if exclude_fields else set()
+        included_fields = set(include_only) if include_only else all_field_names
+        unrecognized_fields = included_fields.difference(all_field_names)
+        if unrecognized_fields:
+            raise QwakException(
+                f"Unknown fields were included: {list(unrecognized_fields)}"
+            )
+        return included_fields.difference(excluded_fields)
+
+    def protofy_decorator(cls):
+        if not hasattr(cls, "__dataclass_fields__"):
+            raise QwakException("Protofy must receive a dataclass")
+
+        fields_mapping = mapping if mapping else {}
+        final_field_names = get_final_field_names(cls)
+
+        def to_proto(self) -> protobuf_class:
+            final_fields = {}
+            for field_name in final_field_names:
+                field_val = self.__getattribute__(field_name)
+                field_name = (
+                    fields_mapping[field_name]
+                    if field_name in fields_mapping
+                    else field_name
+                )
+                final_fields[field_name] = (
+                    field_val.to_proto()
+                    if hasattr(field_val, "to_proto")
+                    else field_val
+                )
+            return protobuf_class(**final_fields)
+
+        setattr(cls, "to_proto", to_proto)
+        return cls
+
+    return protofy_decorator

qwak_sdk/commands/models/build/_logic/util/step_decorator.py

@@ -0,0 +1,60 @@
+import os
+import shutil
+from functools import wraps
+from typing import List
+
+from qwak.exceptions import QuietError
+from qwak.inner.build_logic.interface.build_logger_interface import BuildLogger
+from qwak.inner.build_logic.interface.step_inteface import Step
+
+
+def step_exception_handler_decorator(step: Step):
+    execute_func = step.execute
+
+    @wraps(execute_func)
+    def inner_function(*args, **kwargs):
+        try:
+            execute_func(*args, **kwargs)
+        except BaseException as e:
+            if not isinstance(e, QuietError):
+                build_logger: BuildLogger = step.build_logger
+                build_logger.error(
+                    "Build failed with Exception. See the stack trace above."
+                )
+                cleaning_up_after_build(step)
+            raise e
+
+    return inner_function
+
+
+def build_failure_handler():
+    def _exception_handler(func):
+        @wraps(func)
+        def inner_function(*args, **kwargs):
+            try:
+                func(*args, **kwargs)
+            except BaseException as e:
+                if not isinstance(e, QuietError):
+                    build_logger: BuildLogger = args[0].build_logger
+                    build_logger.error(
+                        "Build failed with Exception. See the stack trace above."
+                    )
+                    cleaning_up_after_build(args[0])
+                raise e
+        return inner_function
+
+    return _exception_handler
+
+
+def cleaning_up_after_build(step: Step):
+    if os.getenv("QWAK_DEBUG") != "true":
+        step.build_logger.debug("Removing Qwak temp artifacts directory")
+        shutil.rmtree(step.context.host_temp_local_build_dir, ignore_errors=True)
+
+
+def add_decorator_to_steps(phase_steps: List[Step]):
+    for step in phase_steps:
+        if not hasattr(step.execute, '__wrapped__'):
+            step_exception_handler_decorator(step)
+
+    return phase_steps

qwak_sdk/commands/models/build/_logic/util/text.py

@@ -0,0 +1,9 @@
+from re import sub
+
+
+def snake_case(s):
+    return "_".join(
+        sub(
+            "([A-Z][a-z]+)", r" \1", sub("([A-Z]+)", r" \1", s.replace("-", " "))
+        ).split()
+    ).lower()

qwak_sdk/commands/models/build/_logic/wait_until_finished.py

@@ -0,0 +1,27 @@
+from logging import Logger
+import time
+from typing import List
+from _qwak_proto.qwak.build.v1.build_pb2 import BuildStatus
+from qwak.clients.build_orchestrator import BuildOrchestratorClient
+
+
+def __get_current_status(build_id) -> BuildStatus:
+    return BuildOrchestratorClient().get_build(build_id).build.build_status
+
+
+def __end_state_statuses() -> List[BuildStatus.ValueType]:
+    return [BuildStatus.FAILED, BuildStatus.SUCCESSFUL, BuildStatus.REMOTE_BUILD_CANCELLED, BuildStatus.REMOTE_BUILD_TIMED_OUT, BuildStatus.FAILED_INITIATING_BUILD]
+
+
+def wait_until_finished(build_id, log: Logger, pool_interval_seconds=10) -> None:
+    status = __get_current_status(build_id)
+    log.info(f"Waiting for build {build_id} to finish. Aborting this process will not stop the build!")
+    log.debug(f"Current status of build {build_id}: {BuildStatus.DESCRIPTOR.values_by_number[status].name}")
+    while status not in __end_state_statuses():
+        time.sleep(pool_interval_seconds)
+        status = __get_current_status(build_id)
+        log.debug(f"Current status of build {build_id}: {BuildStatus.DESCRIPTOR.values_by_number[status].name}")
+
+
+def is_final_status_successful(build_id) -> bool:
+    return __get_current_status(build_id) == BuildStatus.SUCCESSFUL