qwak-core 0.1.37__py3-none-any.whl → 0.5.19__py3-none-any.whl

qwak/inner/build_logic/phases/phase_010_fetch_model/pre_fetch_validation_step.py

@@ -0,0 +1,266 @@
+import uuid
+from pathlib import Path
+
+import grpc
+
+from qwak.clients.secret_service import SecretServiceClient
+from qwak.exceptions import (
+    QwakSuggestionException,
+    QwakException,
+)
+from qwak.inner.build_logic.constants.host_resource import HOST_TEMP_BUILD_DIR
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak.inner.build_logic.tools.dependencies_tools import find_dependency_files
+from qwak.inner.build_logic.tools.text import snake_case
+from qwak.inner.instance_template.verify_template_id import verify_template_id
+from qwak.inner.provider import Provider
+from qwak.model.base import QwakModel
+
+
+class PreFetchValidationStep(Step):
+    STEP_DESCRIPTION = "Pre model fetch validation"
+    DEFAULT_CPUS = 2
+    DEFAULT_MEMORY = "4Gi"
+    VALIDATION_FAILURE_CPU_AND_GPU_MESSAGE = (
+        "CPU and GPU configured together, Invalid configuration."
+    )
+    VALIDATION_FAILURE_CPU_AND_GPU_SUGGESTION = "Please configure only CPU or GPU"
+    VALIDATION_FAILURE_CPU_AND_INSTANCE_MESSAGE = (
+        "CPU and instance configured together, Invalid configuration."
+    )
+    VALIDATION_FAILURE_CPU_AND_INSTANCE_SUGGESTION = (
+        "Please configure only CPU or instance"
+    )
+    VALIDATION_FAILURE_GPU_AND_INSTANCE_MESSAGE = (
+        "GPU and instance configured together, Invalid configuration."
+    )
+    VALIDATION_FAILURE_GPU_AND_INSTANCE_SUGGESTION = (
+        "Please configure only GPU or instance"
+    )
+    EXISTING_MODEL_PASSED_MSG = "Build process was provided with pre built model"
+    INVALID_QWAK_MODEL_MSG_FORMAT = (
+        "The provided qwak model is not of {expected_class} but of {passed_class}"
+    )
+    SERVICE_ACCOUNT_NOT_FOUND = (
+        "GCP service account key secret '{secret_name}' wasn't found"
+    )
+    SERVICE_ACCOUNT_NOT_FOUND_SUGGESTION = "Make sure your GCP service account key secret is configured correctly in the environment"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        self.validate_build_properties()
+        self.create_build_id()
+        self.collect_build_name()
+        self.collect_model_id()
+        self.create_build_dir()
+        self.collect_git_credentials()
+        self.validate_dependencies()
+        self.validate_resources()
+        self.validate_deployment_resources()
+        self.validate_qwak_model()
+        self.validate_gcp_service_account_secret()
+
+    def validate_build_properties(self):
+        if not self.config.build_properties.model_uri.uri:
+            error_message = "Model uri wasn't set"
+            self.build_logger.error(f"{error_message}, failing...")
+
+            raise QwakSuggestionException(
+                message=error_message,
+                suggestion="Make sure your build properties object contains model uri argument",
+            )
+        if (
+            self.config.build_properties.model_uri.git_credentials_secret
+            and self.config.build_properties.model_uri.git_secret_ssh
+        ):
+            error_message = (
+                "Only one of git credentials secret or git secret ssh can be configured"
+            )
+            raise QwakSuggestionException(
+                message=error_message,
+                suggestion="Make sure your git credentials or git secret ssh are configured correctly and only one of "
+                "them is configured",
+            )
+
+    def collect_model_id(self):
+        model_id = self.config.build_properties.model_id
+        model = self.context.client_models_management.get_model(
+            model_id=model_id,
+            exception_on_missing=False,
+        )
+        if not model:
+            suggestion = f"Create model {model_id} or check model ID spelling"
+            snake_case_model_id = snake_case(model_id)
+            if self.context.client_models_management.is_model_exists(
+                snake_case_model_id
+            ):
+                suggestion = f"Try using model ID {snake_case_model_id} instead"
+            raise QwakSuggestionException(
+                message=f"Model ID {model_id} isn't found",
+                suggestion=suggestion,
+            )
+        self.context.project_uuid = model.project_id
+        self.context.model_uuid = model.uuid
+        self.context.model_id = model_id
+
+    def create_build_id(self):
+        if not self.context.build_id:
+            self.context.build_id = str(uuid.uuid4())
+            self.build_logger.info(f"Generated build ID - {self.context.build_id}")
+        else:
+            self.build_logger.info(f"Using given build ID - {self.context.build_id}")
+
+    def collect_build_name(self):
+        build_name: str = self.config.build_properties.build_name
+
+        if build_name:
+            self.build_logger.info(f"Using given build name - {build_name}")
+            self.context.build_name = build_name
+
+    def create_build_dir(self):
+        build_dir = HOST_TEMP_BUILD_DIR / self.context.model_id / self.context.build_id
+        build_dir.mkdir(exist_ok=True, parents=True)
+        self.context.host_temp_local_build_dir = build_dir
+        self.build_logger.debug(f"Build directory created - {build_dir}")
+
+    def collect_git_credentials(self):
+        if self.config.build_properties.model_uri.git_credentials:
+            self.context.git_credentials = (
+                self.config.build_properties.model_uri.git_credentials
+            )
+        elif self.config.build_properties.model_uri.git_credentials_secret:
+            self.context.git_credentials = SecretServiceClient().get_secret(
+                self.config.build_properties.model_uri.git_credentials_secret
+            )
+        elif self.config.build_properties.model_uri.git_secret_ssh:
+            self.context.git_ssh_key = SecretServiceClient().get_secret(
+                self.config.build_properties.model_uri.git_secret_ssh
+            )
+        else:
+            self.build_logger.debug("Git credentials isn't configured")
+
+    def validate_dependencies(self):
+        if (
+            Path(self.config.build_properties.model_uri.uri).is_dir()
+            and not self.config.build_env.python_env.dependency_file_path
+        ):
+            model_uri, main_dir = (
+                Path(self.config.build_properties.model_uri.uri),
+                self.config.build_properties.model_uri.main_dir,
+            )
+            (
+                self.context.dependency_manager_type,
+                self.context.model_relative_dependency_file,
+                self.context.model_relative_dependency_lock_file,
+            ) = find_dependency_files(model_uri, main_dir, self.build_logger)
+
+            if (
+                self.context.dependency_manager_type
+                and self.context.model_relative_dependency_file
+            ):
+                return
+
+            self.build_logger.error("Dependency file wasn't found, failing...")
+            raise QwakSuggestionException(
+                message="Dependency file isn't found",
+                suggestion="Make sure your model include one of dependencies manager: pip/poetry/conda",
+            )
+
+    def validate_resources(self):
+        gpu_configured = (
+            self.config.build_env.remote.resources.gpu_type
+            or self.config.build_env.remote.resources.gpu_amount
+        )
+        cpu_configured = (
+            self.config.build_env.remote.resources.cpus
+            or self.config.build_env.remote.resources.memory
+        )
+        instance_configured = self.config.build_env.remote.resources.instance
+
+        if cpu_configured and gpu_configured:
+            raise QwakSuggestionException(
+                message=self.VALIDATION_FAILURE_CPU_AND_GPU_MESSAGE,
+                suggestion=self.VALIDATION_FAILURE_CPU_AND_GPU_SUGGESTION,
+            )
+        if cpu_configured and instance_configured:
+            raise QwakSuggestionException(
+                message=self.VALIDATION_FAILURE_CPU_AND_INSTANCE_MESSAGE,
+                suggestion=self.VALIDATION_FAILURE_CPU_AND_INSTANCE_SUGGESTION,
+            )
+        if gpu_configured and instance_configured:
+            raise QwakSuggestionException(
+                message=self.VALIDATION_FAILURE_GPU_AND_INSTANCE_MESSAGE,
+                suggestion=self.VALIDATION_FAILURE_GPU_AND_INSTANCE_SUGGESTION,
+            )
+
+        if instance_configured:
+            provider = self.__get_provider()
+            verify_template_id(
+                self.config.build_env.remote.resources.instance,
+                self.context.client_instance_template,
+                provider=provider,
+            )
+
+        if not (cpu_configured or gpu_configured or instance_configured):
+            self.config.build_env.remote.resources.cpus = self.DEFAULT_CPUS
+            self.config.build_env.remote.resources.memory = self.DEFAULT_MEMORY
+
+    def __get_provider(self):
+        user_context = self.context.client_ecosystem.get_authenticated_user_context()
+        provider = None
+        if (
+            user_context.user.environment_details.configuration.cloud_configuration.WhichOneof(
+                "configuration"
+            )
+            == "aws_cloud_configuration"
+        ):
+            provider = Provider.AWS
+        elif (
+            user_context.user.environment_details.configuration.cloud_configuration.WhichOneof(
+                "configuration"
+            )
+            == "gcp_cloud_configuration"
+        ):
+            provider = Provider.GCP
+        return provider
+
+    def validate_deployment_resources(self):
+        if self.config.deploy and self.config.deployment_instance:
+            provider = self.__get_provider()
+            verify_template_id(
+                self.config.deployment_instance,
+                self.context.client_instance_template,
+                provider=provider,
+            )
+
+    def validate_qwak_model(self):
+        if self.config.pre_built_model:
+            self.build_logger.debug(self.EXISTING_MODEL_PASSED_MSG)
+            if not isinstance(self.config.pre_built_model, QwakModel):
+                raise QwakException(
+                    self.INVALID_QWAK_MODEL_MSG_FORMAT.format(
+                        expected_class=QwakModel.__name__,
+                        passed_class=self.config.pre_built_model.__class__,
+                    )
+                )
+
+    def validate_gcp_service_account_secret(self):
+        if self.config.build_env.docker.service_account_key_secret_name:
+            self.build_logger.debug("Checking GCP service account key secret")
+            try:
+                SecretServiceClient().get_secret(
+                    self.config.build_env.docker.service_account_key_secret_name
+                )
+            except QwakException as e:
+                if e.status_code == grpc.StatusCode.NOT_FOUND:
+                    raise QwakSuggestionException(
+                        message=self.SERVICE_ACCOUNT_NOT_FOUND.format(
+                            secret_name=self.config.build_env.docker.service_account_key_secret_name
+                        ),
+                        suggestion=self.SERVICE_ACCOUNT_NOT_FOUND_SUGGESTION,
+                    )
+                raise e
+
+            self.build_logger.debug("service account key secret found")

qwak/inner/build_logic/phases/phase_010_fetch_model/set_version_step.py

@@ -0,0 +1,33 @@
+import importlib
+
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak import __version__ as qwak_core_version
+
+
+class SetVersionStep(Step):
+    STEP_DESCRIPTION = "Getting SDK Version"
+    SDK_VERSION_NOT_AVAILABLE_MSG_FORMAT = (
+        "Sdk version not available, using core version {qwak_core_version}"
+    )
+    SDK_VERSION_FOUND_MSG_FORMAT = "Found sdk version {qwak_sdk_version}"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        try:
+            self.build_logger.debug("Getting sdk version")
+            qwak_sdk_version = importlib.import_module("qwak_sdk").__version__
+            self.context.qwak_sdk_version = qwak_sdk_version
+            self.build_logger.debug(
+                self.SDK_VERSION_FOUND_MSG_FORMAT.format(
+                    qwak_sdk_version=qwak_sdk_version
+                )
+            )
+        except ImportError:
+            self.build_logger.debug(
+                self.SDK_VERSION_NOT_AVAILABLE_MSG_FORMAT.format(
+                    qwak_core_version=qwak_core_version
+                )
+            )
+            self.context.qwak_sdk_version = qwak_core_version

qwak/inner/build_logic/phases/phase_020_remote_register_qwak_build/cleanup_step.py

@@ -0,0 +1,20 @@
+import os
+
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak.inner.build_logic.tools.files import cleaning_up_after_build
+
+
+class CleanupStep(Step):
+    STEP_DESCRIPTION = "Clean build artifacts"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        self.build_logger.debug(
+            "Cleanup environment - Deleting file and intermediate images"
+        )
+        if os.getenv("POD_NAME"):
+            self.build_logger.debug("Skipping cleanup - Remote executor is temporary")
+        else:
+            cleaning_up_after_build(self)

qwak/inner/build_logic/phases/phase_020_remote_register_qwak_build/start_remote_build_step.py

@@ -0,0 +1,43 @@
+from copy import deepcopy
+
+from _qwak_proto.qwak.builds.build_url_pb2 import BuildVersioningTagsType
+from qwak.inner.build_logic.constants.upload_tag import (
+    BUILD_CONFIG_TAG,
+    QWAK_SDK_VERSION_TAG,
+    MODEL_CODE_TAG,
+)
+
+from qwak.inner.build_logic.interface.step_inteface import Step
+
+
+class StartRemoteBuildStep(Step):
+    STEP_DESCRIPTION = "Start remote build"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        self.build_logger.info(f"Start remote build - {self.context.build_id}")
+        config_copy = deepcopy(self.config)
+        config_copy.build_properties.build_id = self.context.build_id
+        config_copy.build_properties.build_name = self.context.build_name
+        self.context.client_builds_orchestrator.build_model(
+            build_conf=config_copy,
+            build_v1_flag=False,
+            build_config_url=self.get_download_url(BUILD_CONFIG_TAG),
+            qwak_sdk_version_url=self.get_download_url(QWAK_SDK_VERSION_TAG),
+            resolved_model_url=self.get_download_url(MODEL_CODE_TAG),
+            git_commit_id=self.context.git_commit_id,
+            sdk_version=self.context.qwak_sdk_version,
+        )
+        self.build_logger.info("Remote build started successfully")
+
+    def get_download_url(self, tag: str) -> str:
+        return (
+            self.context.client_builds_orchestrator.get_build_versioning_download_url(
+                model_id=self.config.build_properties.model_id,
+                build_id=self.context.build_id,
+                tag=tag,
+                tag_type=BuildVersioningTagsType.FILE_TAG_TYPE,
+            ).download_url
+        )

qwak/inner/build_logic/phases/phase_020_remote_register_qwak_build/upload_step.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any, List, Tuple, Union, Optional
+
+import joblib
+import requests
+from retrying import retry
+
+from _qwak_proto.qwak.builds.build_url_pb2 import BuildVersioningTagsType
+from _qwak_proto.qwak.builds.builds_orchestrator_service_pb2 import (
+    GetBuildVersioningUploadURLResponse,
+)
+from qwak.exceptions import QwakException
+from qwak.exceptions import QwakGeneralBuildException
+from qwak.inner.build_logic.constants.temp_dir import TEMP_LOCAL_MODEL_DIR
+from qwak.inner.build_logic.constants.upload_tag import (
+    MODEL_CODE_TAG,
+    SKINNY_MODEL_CODE_TAG,
+    QWAK_SDK_VERSION_TAG,
+    BUILD_CONFIG_TAG,
+    QWAK_RUNTIME_WHEEL_TAG,
+    QWAK_CORE_WHEEL_TAG,
+    QWAK_BUILT_MODEL_TAG,
+)
+from qwak.inner.build_logic.interface.step_inteface import Step
+from qwak.inner.build_logic.tools.files import (
+    QWAK_IGNORE_FILE_NAME,
+    IGNORED_PATTERNS_FOR_UPLOAD,
+    zip_model,
+    UploadInChunks,
+)
+from qwak.inner.build_logic.tools.ignore_files import load_patterns_from_ignore_file
+
+_MAX_FILE_SIZE_BYTES = 10000000
+
+
+def should_retry(qwak_exception: QwakException):
+    # when Got 403 from Jfrog it means that the reposity doesn't exist. It may happen when in the first build in the project
+    return str(qwak_exception.message).__contains__("403")
+
+
+class UploadStep(Step):
+    STEP_DESCRIPTION = "Saving Qwak Model"
+
+    def description(self) -> str:
+        return self.STEP_DESCRIPTION
+
+    def execute(self) -> None:
+        files_tag_iterator = self.create_files_to_upload()
+        files_total_size = sum(
+            file.stat().st_size for (file, tag) in files_tag_iterator
+        )
+        upload_so_far = 0
+        for file, tag in files_tag_iterator:
+            if file.exists():
+                pre_signed_url = self.upload_file(
+                    file=file,
+                    tag=tag,
+                    all_files_size_to_upload=files_total_size,
+                    read_so_far=upload_so_far,
+                )
+                upload_so_far += file.stat().st_size
+
+                if tag == MODEL_CODE_TAG:
+                    self.context.model_code_remote_url = str(pre_signed_url).split("?")[
+                        0
+                    ]
+
+    def create_files_to_upload(self) -> Union[List[Tuple[Any, Any], Tuple[Path, Any]]]:
+        ignored_patterns = (
+            load_patterns_from_ignore_file(
+                build_logger=self.build_logger,
+                ignore_file_path=self.context.host_temp_local_build_dir
+                / TEMP_LOCAL_MODEL_DIR
+                / self.config.build_properties.model_uri.main_dir
+                / QWAK_IGNORE_FILE_NAME,
+            )
+            + IGNORED_PATTERNS_FOR_UPLOAD
+        )
+
+        # copy 'main' and 'tests' directories
+        dirs_to_include = [self.config.build_properties.model_uri.main_dir, "tests"]
+        deps_folders = []
+        for (
+            folder
+        ) in self.config.build_properties.model_uri.dependency_required_folders:
+            destination_folder = folder
+            while destination_folder.startswith(".."):
+                destination_folder = re.sub(r"^\.\./", "", destination_folder)
+            deps_folders.append(destination_folder)
+        if deps_folders:
+            self.build_logger.debug(
+                f"Adding dependency folders to model code: {deps_folders}"
+            )
+            dirs_to_include += deps_folders
+
+        self.build_logger.debug("Zipping skinny model code")
+        skinny_size_zip_file = zip_model(
+            build_dir=self.context.host_temp_local_build_dir,
+            dependency_file=self.context.model_relative_dependency_file,
+            deps_lock_file=self.context.model_relative_dependency_lock_file,
+            dirs_to_include=dirs_to_include,
+            zip_name="skinny_size_model_code",
+            ignored_patterns=ignored_patterns,
+            max_bytes=_MAX_FILE_SIZE_BYTES,
+        )
+
+        # Full size model
+        self.build_logger.debug("Zipping full model code")
+        full_size_zip_file = zip_model(
+            build_dir=self.context.host_temp_local_build_dir,
+            dependency_file=self.context.model_relative_dependency_file,
+            deps_lock_file=self.context.model_relative_dependency_lock_file,
+            dirs_to_include=dirs_to_include,
+            zip_name="full_size_model_code",
+            ignored_patterns=ignored_patterns,
+        )
+
+        # Dump config file for upload
+        config_file_temp = self.context.host_temp_local_build_dir / "build.conf"
+        config_file_temp.write_text(self.config.to_yaml())
+
+        # Dump qwak-sdk version for upload
+        qwak_sdk_version_temp = self.context.host_temp_local_build_dir / "VERSION"
+        qwak_sdk_version_temp.write_text(self.context.qwak_sdk_version)
+
+        files_tag_iterator = [
+            (full_size_zip_file, MODEL_CODE_TAG),
+            (skinny_size_zip_file, SKINNY_MODEL_CODE_TAG),
+            (qwak_sdk_version_temp, QWAK_SDK_VERSION_TAG),
+            (config_file_temp, BUILD_CONFIG_TAG),
+        ]
+
+        if self.context.custom_runtime_wheel:
+            files_tag_iterator.append(
+                (self.context.custom_runtime_wheel, QWAK_RUNTIME_WHEEL_TAG)
+            )
+
+        if self.context.custom_core_wheel:
+            files_tag_iterator.append(
+                (self.context.custom_core_wheel, QWAK_CORE_WHEEL_TAG)
+            )
+
+        if self.config.pre_built_model:
+            temp_model_file = (
+                self.context.host_temp_local_build_dir / QWAK_BUILT_MODEL_TAG
+            )
+            joblib.dump(self.config.pre_built_model, temp_model_file, compress=3)
+            files_tag_iterator.append((temp_model_file, QWAK_BUILT_MODEL_TAG))
+
+        return files_tag_iterator
+
+    def upload_file(
+        self, file: Path, tag: str, all_files_size_to_upload: int, read_so_far: int
+    ):
+        self.build_logger.debug(f"Upload file {file}")
+
+        pre_signed_url_response: GetBuildVersioningUploadURLResponse = (
+            self.get_pre_signed_upload_url(
+                tag=tag, tag_type=BuildVersioningTagsType.FILE_TAG_TYPE
+            )
+        )
+        self.upload_file_to_remote_storge(
+            upload_url=pre_signed_url_response.upload_url,
+            file=file,
+            all_files_size_to_upload=all_files_size_to_upload,
+            read_so_far=read_so_far,
+            headers=pre_signed_url_response.headers,
+        )
+
+        self.build_logger.debug(f"Upload file {file} completed")
+
+        return pre_signed_url_response.upload_url
+
+    def get_pre_signed_upload_url(
+        self, tag: str, tag_type: Optional[BuildVersioningTagsType]
+    ) -> GetBuildVersioningUploadURLResponse:
+        try:
+            self.build_logger.debug(f"Getting pre-signed url for upload - tag {tag}")
+
+            pre_signed_url_response: GetBuildVersioningUploadURLResponse = (
+                self.context.client_builds_orchestrator.get_build_versioning_upload_url(
+                    build_id=self.context.build_id,
+                    model_id=self.context.model_id,
+                    tag=tag,
+                    tag_type=tag_type,
+                )
+            )
+
+            self.build_logger.debug("Pre-signed url generated successfully")
+
+            return pre_signed_url_response
+        except QwakException as e:
+            raise QwakGeneralBuildException(
+                message="Unable to get pre-signed url for uploading model",
+                src_exception=e,
+            )
+
+    def upload_file_to_remote_storge(
+        self,
+        upload_url: str,
+        file: Path,
+        all_files_size_to_upload: int,
+        read_so_far: int,
+        headers: Optional[dict] = None,
+    ):
+        if not headers:
+            headers = {}
+
+        try:
+            self.build_logger.debug(f"Upload file {file} to Qwak storage")
+
+            self.send_request(
+                upload_url, file, all_files_size_to_upload, read_so_far, headers
+            )
+            self.build_logger.debug(
+                f"File {file} uploaded to Qwak storage successfully"
+            )
+        except Exception as e:
+            raise QwakGeneralBuildException(
+                message="Fail uploading model to remote storage.",
+                src_exception=e,
+            )
+
+    @retry(retry_on_exception=should_retry, wait_fixed=15000, stop_max_delay=60000)
+    def send_request(
+        self,
+        upload_url: str,
+        file: Path,
+        all_files_size_to_upload: int,
+        read_so_far: int,
+        headers: Optional[dict],
+    ):
+        if not headers:
+            headers = {}
+
+        # Adding to the current headers the content-type
+        headers["content-type"] = "text/plain"
+
+        http_response = requests.put(  # nosec B113
+            url=upload_url,
+            data=UploadInChunks(
+                file=file,
+                build_logger=self.build_logger,
+                chunk_size_bytes=10,
+                all_files_size_to_upload=all_files_size_to_upload,
+                read_so_far=read_so_far,
+            ),
+            headers=headers,
+        )
+
+        if http_response.status_code not in [200, 201]:
+            raise QwakException(
+                f"Status: [{http_response.status_code}], "
+                f"reason: [{http_response.reason}]"
+            )

qwak/inner/build_logic/phases/phases_pipeline.py

@@ -0,0 +1,44 @@
+from typing import List, Optional
+
+from qwak.inner.build_config.build_config_v1 import BuildConfigV1
+from ..interface.build_phase import BuildPhase
+from ..interface.context_interface import Context
+
+from qwak.inner.build_logic.interface.step_inteface import Step
+
+
+class PhasesPipeline:
+    def __init__(
+        self,
+        config: Optional[BuildConfigV1],
+        context: Context,
+        build_phase: Optional[BuildPhase] = None,
+    ) -> None:
+        self._phases: List[PhasesPipeline] = []
+        self._steps: List[Step] = []
+        self.context = context
+        self._config = config
+        self.build_phase = build_phase
+
+    @property
+    def phases(self) -> List["PhasesPipeline"]:
+        return self._phases
+
+    @property
+    def steps(self) -> List[Step]:
+        return self._steps
+
+    def add_phase(self, steps: List[Step], build_phase: BuildPhase):
+        phase = PhasesPipeline(
+            config=self._config,
+            context=self.context,
+            build_phase=build_phase,
+        )
+
+        for step in steps:
+            step.context = self.context
+            step.config = self._config
+            step.build_phase = build_phase
+            phase._steps.append(step)
+
+        self._phases.append(phase)