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

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

@@ -0,0 +1,189 @@
+import logging
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+from qwak.exceptions import QwakException
+from yaspin.core import Yaspin
+
+from qwak_sdk.tools.colors import Color
+
+from .messages import (
+    FAILED_CONTACT_QWAK_SUPPORT,
+    FAILED_CONTACT_QWAK_SUPPORT_PROGRAMMATIC,
+)
+from .utils import zip_logs
+
+
+class BuildRunHandler(ABC):
+    @abstractmethod
+    def handle_phase_in_progress(self, phase_id: str):
+        pass
+
+    @abstractmethod
+    def handle_phase_finished_successfully(
+        self, phase_id: str, duration_in_seconds: int
+    ):
+        pass
+
+    @abstractmethod
+    def handle_contact_support_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        pass
+
+    @abstractmethod
+    def handle_remote_build_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        pass
+
+    @abstractmethod
+    def handle_keyboard_interrupt(
+        self, build_id: str, phase_id: str, duration_in_seconds: int
+    ):
+        pass
+
+    @abstractmethod
+    def handle_pipeline_exception(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        pass
+
+    @abstractmethod
+    def handle_pipeline_quiet_exception(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        pass
+
+    def build_phase_to_human_readable_string(self, phase_id: str):
+        return phase_id[len("BuildPhase.") :].replace("_", " ").capitalize()
+
+
+class CLIBuildRunner(BuildRunHandler):
+    def __init__(self, sp: Yaspin, log_path: Path):
+        self.sp = sp
+        self.log_path = str(log_path)
+
+    def handle_phase_in_progress(self, phase_id: str):
+        logging.debug(
+            f"Build phase in progress: {self.build_phase_to_human_readable_string(phase_id)}"
+        )
+
+    def handle_phase_finished_successfully(
+        self, phase_id: str, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.ok("✅")
+
+        logging.debug(
+            f"Phase successfully finished: {self.build_phase_to_human_readable_string(phase_id)} after {duration_in_seconds} seconds"
+        )
+
+    def __report_failure(self, phase_id: str, duration_in_seconds: int):
+        logging.debug(
+            f"Build phase failed: {self.build_phase_to_human_readable_string(phase_id)} after {duration_in_seconds} seconds"
+        )
+
+    def handle_contact_support_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        print(f"\n{ex}")
+        print(
+            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(phase_id, duration_in_seconds)
+        exit(1)
+
+    def handle_remote_build_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.fail("💥")
+            print(f"\n{Color.RED}{ex}")
+        else:
+            print(f"\n{ex}")
+        self.__report_failure(phase_id, duration_in_seconds)
+        exit(1)
+
+    def handle_keyboard_interrupt(
+        self, build_id: str, phase_id: str, duration_in_seconds: int
+    ):
+        print(f"\n{Color.RED}Stopping Qwak build (ctrl-c)")
+        zip_logs(log_path=self.log_path, build_id=build_id)
+        self.__report_failure(phase_id, duration_in_seconds)
+        exit(1)
+
+    def handle_pipeline_exception(
+        self, build_id: str, phase_id: str, 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(phase_id, duration_in_seconds)
+        exit(1)
+
+    def handle_pipeline_quiet_exception(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        if self.sp:
+            self.sp.ok("‼️")
+        self.__report_failure(phase_id, duration_in_seconds)
+
+
+class ProgrammaticBuildRunner(BuildRunHandler):
+    def handle_phase_in_progress(self, phase_id: str):
+        logging.debug(
+            f"Build phase in progress: {self.build_phase_to_human_readable_string(phase_id)}"
+        )
+
+    def handle_phase_finished_successfully(
+        self, phase_id: str, duration_in_seconds: int
+    ):
+        logging.debug(
+            f"Phase successfully finished: {self.build_phase_to_human_readable_string(phase_id)} after {duration_in_seconds} seconds"
+        )
+
+    def __report_failure(self, phase_id: str, duration_in_seconds: int):
+        logging.debug(
+            f"Build phase failed: {self.build_phase_to_human_readable_string(phase_id)} after {duration_in_seconds} seconds"
+        )
+
+    def handle_contact_support_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        print(
+            FAILED_CONTACT_QWAK_SUPPORT_PROGRAMMATIC.format(
+                build_id=build_id,
+            )
+        )
+        self.__report_failure(phase_id, duration_in_seconds)
+        raise QwakException(str(ex))
+
+    def handle_keyboard_interrupt(
+        self, build_id: str, phase_id: str, duration_in_seconds: int
+    ):
+        self.__report_failure(phase_id, duration_in_seconds)
+
+    def handle_pipeline_exception(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        self.__report_failure(phase_id, duration_in_seconds)
+        raise QwakException(str(ex))
+
+    def handle_pipeline_quiet_exception(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        self.__report_failure(phase_id, duration_in_seconds)
+
+    def handle_remote_build_error(
+        self, build_id: str, phase_id: str, ex: BaseException, duration_in_seconds: int
+    ):
+        self.handle_pipeline_exception(build_id, phase_id, ex, duration_in_seconds)

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

@@ -0,0 +1,125 @@
+from typing import Tuple
+
+from qwak.exceptions import QuietError
+
+from qwak_sdk.commands.models.build._logic.context import Context
+from qwak_sdk.exceptions import QwakGeneralBuildException
+from qwak_sdk.exceptions.qwak_remote_build_failed import QwakRemoteBuildFailedException
+
+from ..build_steps import StepsPipeline, remote_build_steps
+from ..config.config_v1 import ConfigV1
+from ..interface.notifier_interface import Notifier
+from .build_run_handlers import BuildRunHandler, CLIBuildRunner, ProgrammaticBuildRunner
+from .logger import build_logger
+from .messages import SUCCESS_MSG_REMOTE, SUCCESS_MSG_REMOTE_WITH_DEPLOY
+from .notifier_impl import NotifierImpl
+from .spinner import spinner
+from .time_source import Stopwatch, SystemClockTimeSource, TimeSource
+from .utils import zip_logs
+
+
+def execute_build_pipeline(
+    config: ConfigV1,
+    json_logs: bool,
+    programmatic: bool = False,
+):
+    with build_logger(config=config, json_logs=json_logs) as (
+        logger,
+        log_path,
+    ):
+        pipeline, success_msg = create_pipeline(config)
+
+        time_source = SystemClockTimeSource()
+        for phase in pipeline.phases:
+            phase_details = phase.get_phase_details()
+            notifier = NotifierImpl(
+                logger,
+                prefix="" if json_logs else phase_details.get_description(),
+                phase_details=phase_details,
+            )
+
+            if programmatic:
+                build_runner = ProgrammaticBuildRunner()
+                phase_run(phase, pipeline.context, build_runner, notifier, time_source)
+            else:
+                with spinner(
+                    text=phase_details.get_description(),
+                    show=(config.verbose == 0 and not json_logs),
+                ) as sp:
+                    notifier.set_spinner(sp)
+                    build_runner = CLIBuildRunner(sp, log_path)
+                    phase_run(
+                        phase, pipeline.context, build_runner, notifier, time_source
+                    )
+
+    print(
+        success_msg.format(
+            build_id=pipeline.context.build_id,
+            model_id=pipeline.context.model_id,
+            project_uuid=pipeline.context.project_uuid,
+        )
+    )
+    zip_logs(log_path=log_path, build_id=pipeline.context.build_id)
+
+    return pipeline.context.build_id
+
+
+def phase_run(
+    phase: StepsPipeline,
+    context: Context,
+    build_runner: BuildRunHandler,
+    notifier: Notifier,
+    time_source: TimeSource,
+):
+    build_id = context.build_id
+    current_step_phase = None
+    stop_watch = Stopwatch(time_source)
+    try:
+        for step in phase.steps:
+            current_step_phase = str(step.build_phase)
+            step.set_notifier(notifier)
+            build_runner.handle_phase_in_progress(current_step_phase)
+
+            step.execute()
+
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        build_runner.handle_phase_finished_successfully(
+            current_step_phase, phase_duration
+        )
+    except QwakGeneralBuildException as e:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        build_runner.handle_contact_support_error(
+            build_id, current_step_phase, e, phase_duration
+        )
+    except QwakRemoteBuildFailedException as e:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        build_runner.handle_remote_build_error(
+            build_id, current_step_phase, e, phase_duration
+        )
+    except KeyboardInterrupt:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        build_runner.handle_keyboard_interrupt(
+            build_id, current_step_phase, phase_duration
+        )
+    except BaseException as e:
+        notifier.exception("Failed", e)
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        if not isinstance(e, QuietError):
+            build_runner.handle_pipeline_exception(
+                build_id, current_step_phase, e, phase_duration
+            )
+        else:
+            build_runner.handle_pipeline_quiet_exception(
+                build_id, current_step_phase, e, phase_duration
+            )
+
+
+def create_pipeline(
+    config: ConfigV1,
+) -> Tuple[StepsPipeline, str]:
+    success_message = (
+        SUCCESS_MSG_REMOTE_WITH_DEPLOY if config.deploy else SUCCESS_MSG_REMOTE
+    )
+    pipeline = remote_build_steps(config)
+
+    return pipeline, success_message

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_sdk import __version__ as qwak_sdk_version
+from qwak_sdk.commands.models.build._logic.config.config_v1 import ConfigV1
+from qwak_sdk.commands.models.build._logic.constant.host_resource import (
+    HOST_QWAK_HIDDEN_FOLDER,
+)
+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
+
+
+@contextlib.contextmanager
+def build_logger(config: ConfigV1, 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[verbosity_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,40 @@
+BUILD_LOGS_URL = (
+    "https://app.qwak.ai/projects/{project_uuid}/{model_id}/build/{build_id}"
+)
+
+SUCCESS_MSG_REMOTE = """
+Build ID \033[4m{build_id}\033[0m triggered remotely
+
+########### To follow build logs using CLI
+qwak models builds logs -b {build_id} --follow
+
+########### To follow build logs using Qwak platform
+https://app.qwak.ai/projects/{project_uuid}/{model_id}/build/{build_id}
+"""
+
+SUCCESS_MSG_REMOTE_WITH_DEPLOY = """
+Build ID \033[4m{build_id}\033[0m finished successfully and deployed
+
+########### To view the model using Qwak platform
+https://app.qwak.ai/projects/{project_uuid}/{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 Qwak support.
+"""
+
+FAILED_CONTACT_QWAK_SUPPORT_PROGRAMMATIC = """
+Build ID \033[4m{build_id}\033[0m failed!!
+"""
+
+FAILED_REMOTE_BUILD_SUGGESTION = """
+Your build failed. You can check the reason for the failure in the Qwak Platform:
+https://app.qwak.ai/projects/{project_uuid}/{model_id}/build/{build_id}
+"""
+
+FAILED_DEPLOY_BUILD_SUGGESTION = """
+Deploying the build Failed. You can check the reason for the failure in the Qwak Platform:
+https://app.qwak.ai/projects/{project_uuid}/{model_id}?tabId=1
+Since the build finished successfully, you can try and redeploy it either from the platform or from the CLI
+"""

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

@@ -0,0 +1,49 @@
+import logging
+from logging import Logger
+
+from yaspin.core import Yaspin
+
+from qwak_sdk.commands.models.build._logic.constant.step_description import PhaseDetails
+from qwak_sdk.commands.models.build._logic.interface.notifier_interface import Notifier
+
+
+class NotifierImpl(Notifier):
+    def __init__(
+        self, logger: Logger, prefix: str, phase_details: PhaseDetails
+    ) -> None:
+        self.logger = logging.LoggerAdapter(
+            logger,
+            {
+                "phase": phase_details.get_description(),
+                "phase_id": phase_details.get_id(),
+            },
+        )
+        self.prefix = f"{prefix} - " if prefix else ""
+        self.spinner = None
+
+    def set_spinner(self, spinner: Yaspin):
+        self.spinner = spinner
+
+    def exception(self, line: str, e: BaseException) -> None:
+        self.logger.error(
+            f"""Message: {line}
+Exception: {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/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/time_source.py

@@ -0,0 +1,37 @@
+from abc import ABC, abstractmethod
+from time import time
+from typing import List
+
+
+class TimeSource(ABC):
+    @abstractmethod
+    def current_epoch_time(self) -> int:
+        pass
+
+
+class Stopwatch:
+    def __init__(self, time_source: TimeSource):
+        self.time_source = time_source
+        self.start_time = self.time_source.current_epoch_time()
+
+    def elapsed_time_in_seconds(self) -> int:
+        end_time = self.time_source.current_epoch_time()
+        return end_time - self.start_time
+
+
+class SystemClockTimeSource(TimeSource):
+    def current_epoch_time(self) -> int:
+        return int(time())
+
+
+class MockClockTimeSource(TimeSource):
+    def __init__(self, time_values=None):
+        self.time_values = []
+        if time_values:
+            self.time_values = list(time_values)
+
+    def current_epoch_time(self) -> int:
+        return self.time_values.pop(0)
+
+    def set_epoch_time_values(self, values: List[int]) -> None:
+        self.time_values = values

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)