frogml-core 0.0.116__py3-none-any.whl → 0.0.117__py3-none-any.whl

core/feature_store/sinks/streaming/attachment.py

@@ -0,0 +1,34 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from frogml._proto.qwak.feature_store.sinks.sink_pb2 import (
+    OfflineStreamingAttachmentPoint as ProtoOfflineStreamingAttachmentPoint,
+)
+from frogml._proto.qwak.feature_store.sinks.sink_pb2 import (
+    OnlineStreamingAttachmentPoint as ProtoOnlineStreamingAttachmentPoint,
+)
+from frogml._proto.qwak.feature_store.sinks.sink_pb2 import (
+    StreamingAttachmentPoint as ProtoStreamingAttachmentPoint,
+)
+
+
+class StreamingAttachmentPoint(ABC):
+    @abstractmethod
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        pass
+
+
+@dataclass
+class OfflineStreamingAttachmentPoint(StreamingAttachmentPoint):
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        return ProtoStreamingAttachmentPoint(
+            offline_streaming_attachment_point=ProtoOfflineStreamingAttachmentPoint()
+        )
+
+
+@dataclass
+class OnlineStreamingAttachmentPoint(StreamingAttachmentPoint):
+    def _to_proto(self) -> ProtoStreamingAttachmentPoint:
+        return ProtoStreamingAttachmentPoint(
+            online_streaming_attachment_point=ProtoOnlineStreamingAttachmentPoint()
+        )

core/feature_store/validations/validation_options.py

@@ -0,0 +1,82 @@
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Optional
+
+from google.protobuf.timestamp_pb2 import Timestamp as ProtoTimestamp
+
+from frogml._proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    DataSourceValidationOptions as ProtoDataSourceValidationOptions,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    FeatureSetValidationOptions as ProtoFeatureSetValidationOptions,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    ValidationTimeRange as ProtoValidationTimeRange,
+)
+from frogml.core.utils.datetime_utils import datetime_to_pts
+
+
+@dataclass
+class ValidationTimeRange:
+    lower_time_bound: Optional[datetime] = None
+    upper_time_bound: Optional[datetime] = None
+
+    def to_proto(self) -> ProtoValidationTimeRange:
+        lower_time_bound_proto: Optional[ProtoTimestamp] = None
+        upper_time_bound_proto: Optional[ProtoTimestamp] = None
+
+        if self.lower_time_bound:
+            lower_time_bound_proto = datetime_to_pts(self.lower_time_bound)
+        if self.upper_time_bound:
+            upper_time_bound_proto = datetime_to_pts(self.upper_time_bound)
+
+        return ProtoValidationTimeRange(
+            lower_time_bound=lower_time_bound_proto,
+            upper_time_bound=upper_time_bound_proto,
+        )
+
+
+@dataclass
+class DataSourceValidationOptions:
+    time_range: Optional[ValidationTimeRange] = field(
+        default_factory=lambda: ValidationTimeRange()
+    )
+
+    def __init__(
+        self,
+        lower_time_bound: Optional[datetime] = None,
+        upper_time_bound: Optional[datetime] = None,
+    ):
+        self.time_range = ValidationTimeRange(
+            lower_time_bound=lower_time_bound, upper_time_bound=upper_time_bound
+        )
+
+    def to_proto(self) -> ProtoDataSourceValidationOptions:
+        return ProtoDataSourceValidationOptions(
+            validation_time_range=self.time_range.to_proto()
+        )
+
+
+@dataclass
+class FeatureSetValidationOptions:
+    time_range: Optional[ValidationTimeRange] = field(
+        default_factory=lambda: ValidationTimeRange()
+    )
+    data_source_limit: Optional[int] = None
+
+    def __init__(
+        self,
+        lower_time_bound: Optional[datetime] = None,
+        upper_time_bound: Optional[datetime] = None,
+        data_source_limit: Optional[int] = None,
+    ):
+        self.time_range = ValidationTimeRange(
+            lower_time_bound=lower_time_bound, upper_time_bound=upper_time_bound
+        )
+        self.data_source_limit = data_source_limit
+
+    def to_proto(self) -> ProtoFeatureSetValidationOptions:
+        return ProtoFeatureSetValidationOptions(
+            data_source_limit=self.data_source_limit,
+            validation_time_range=self.time_range.to_proto(),
+        )

core/feature_store/validations/validation_response.py

@@ -0,0 +1,121 @@
+import ast
+from abc import ABC
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, List
+
+from frogml._proto.qwak.feature_store.features.feature_set_pb2 import (
+    Feature as ProtoFeature,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_async_service_pb2 import (
+    GetValidationResultResponse as ProtoGetValidationResultResponse,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_pb2 import (
+    SparkColumnDescription as ProtoSparkColumnDescription,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_pb2 import (
+    ValidationFailureResponse as ProtoValidationFailureResponse,
+)
+from frogml._proto.qwak.features_operator.v3.features_operator_pb2 import (
+    ValidationSuccessResponse as ProtoValidationSuccessResponse,
+)
+from frogml.core.exceptions import FrogmlException
+
+if TYPE_CHECKING:
+    try:
+        import pandas as pd
+    except ImportError:
+        pass
+
+_VALIDATION_RESPONSE_TYPE_SUCCESS = "success_response"
+_VALIDATION_RESPONSE_TYPE_FAILURE = "failure_response"
+_VALIDATION_RESPONSE_TYPE_TIMEOUT = "not_ready_response"
+
+
+class ValidationResponse(ABC):
+    pass
+
+
+@dataclass
+class TimeoutValidationResponse(ValidationResponse):
+    pass
+
+
+@dataclass
+class FailureValidationResponse(ValidationResponse):
+    phase: str
+    message: str
+    stdout: str
+    stderr: str
+
+
+@dataclass
+class SuccessValidationResponse(ValidationResponse):
+    sample: "pd.DataFrame"
+    features: List[ProtoFeature]
+    stdout: str
+    stderr: str
+
+
+class ValidationResponseFactory:
+    @staticmethod
+    def _get_features(
+        spark_columns_description: List[ProtoSparkColumnDescription],
+    ) -> List[ProtoFeature]:
+        spark_features = []
+        for spark_column in spark_columns_description:
+            feature_col_name_list = str(spark_column.column_name).split(".")
+            feature_name = (
+                feature_col_name_list[1]
+                if feature_col_name_list.__len__() == 2
+                else spark_column.column_name
+            )
+            spark_features.append(
+                ProtoFeature(
+                    feature_name=feature_name,
+                    feature_type=spark_column.spark_type,
+                )
+            )
+        return spark_features
+
+    @staticmethod
+    def from_proto(
+        validation_response: ProtoGetValidationResultResponse,
+    ) -> ValidationResponse:
+        try:
+            import pandas as pd
+        except ImportError:
+            raise FrogmlException("Missing required Pandas dependency")
+
+        validation_type: str = validation_response.WhichOneof("type")
+        if validation_type == _VALIDATION_RESPONSE_TYPE_SUCCESS:
+            success: ProtoValidationSuccessResponse = (
+                validation_response.success_response
+            )
+            pd_sample: pd.DataFrame = pd.read_json(
+                path_or_buf=ast.literal_eval(success.sample),
+                dtype=success.spark_column_description,
+            )
+
+            features = ValidationResponseFactory._get_features(
+                success.spark_column_description
+            )
+            return SuccessValidationResponse(
+                sample=pd_sample,
+                features=features,
+                stdout=success.outputs.stdout,
+                stderr=success.outputs.stderr,
+            )
+        elif validation_type == _VALIDATION_RESPONSE_TYPE_FAILURE:
+            failure: ProtoValidationFailureResponse = (
+                validation_response.failure_response
+            )
+            return FailureValidationResponse(
+                phase=failure.phase,
+                message=failure.error_message,
+                stdout=failure.outputs.stdout,
+                stderr=failure.outputs.stderr,
+            )
+        elif validation_type == _VALIDATION_RESPONSE_TYPE_TIMEOUT:
+            return TimeoutValidationResponse()
+
+        raise FrogmlException(f"Got unsupported response type: {validation_type}")

core/inner/build_config/build_config_v1.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from os.path import expandvars
+from typing import Dict, List, Optional, Tuple, Union
+
+import grpc
+
+from frogml._proto.qwak.builds.build_pb2 import BaseDockerImageType
+from frogml._proto.qwak.builds.builds_pb2 import (
+    BuildConfiguration,
+    BuildEnvironment,
+    BuildModelUri,
+    BuildPropertiesProto,
+    CondaBuild,
+    DockerBuild,
+    PoetryBuild,
+    PythonBuild,
+    RemoteBuild,
+)
+from frogml._proto.qwak.builds.builds_pb2 import (
+    RemoteBuildResources as RemoteBuildResourcesProto,
+)
+from frogml._proto.qwak.builds.builds_pb2 import Step, VirtualEnvironmentBuild
+from frogml._proto.qwak.instance_template.instance_template_pb2 import InstanceType
+from frogml.core.clients.build_orchestrator import BuildOrchestratorClient
+from frogml.core.clients.instance_template.client import (
+    InstanceTemplateManagementClient,
+)
+from frogml.core.exceptions import FrogmlException
+from frogml.core.inner.tool.protobuf_factory import protobuf_factory
+from frogml.core.inner.tool.run_config import (
+    ConfigCliMap,
+    FrogmlConfigBase,
+    YamlConfigMixin,
+    validate_bool,
+    validate_float,
+    validate_int,
+    validate_list_of_strings,
+    validate_string,
+)
+from frogml.core.inner.tool.run_config import (
+    validate_positive_int,
+    validate_purchase_option,
+)
+from frogml.sdk.model.base import BaseModel
+
+CONFIG_MAPPING: List[ConfigCliMap] = [
+    # ConfigV1
+    ConfigCliMap(
+        "validate_build_artifact", "step.validate_build_artifact", validate_bool, True
+    ),
+    ConfigCliMap(
+        "validate_build_artifact_timeout",
+        "step.validate_build_artifact_timeout",
+        validate_positive_int,
+        True,
+    ),
+    ConfigCliMap("tests", "step.tests", validate_bool, True),
+    # BuildProperties
+    ConfigCliMap("model_id", "build_properties.model_id", validate_string, True),
+    ConfigCliMap("build_id", "build_properties.build_id", validate_string, False),
+    ConfigCliMap(
+        "gpu_compatible", "build_properties.gpu_compatible", validate_bool, True
+    ),
+    ConfigCliMap("branch", "build_properties.branch", validate_string),
+    ConfigCliMap("tags", "build_properties.tags", validate_list_of_strings),
+    ConfigCliMap("build_name", "build_properties.build_name", validate_string),
+    # ModelUri
+    ConfigCliMap("uri", "build_properties.model_uri.uri", validate_string, False),
+    ConfigCliMap(
+        "git_branch", "build_properties.model_uri.git_branch", validate_string
+    ),
+    ConfigCliMap("main_dir", "build_properties.model_uri.main_dir", validate_string),
+    ConfigCliMap(
+        "git_credentials", "build_properties.model_uri.git_credentials", validate_string
+    ),
+    ConfigCliMap(
+        "git_secret_ssh", "build_properties.model_uri.git_secret_ssh", validate_string
+    ),
+    ConfigCliMap(
+        "git_credentials_secret",
+        "build_properties.model_uri.git_credentials_secret",
+        validate_string,
+    ),
+    ConfigCliMap(
+        "dependency_required_folders",
+        "build_properties.model_uri.dependency_required_folders",
+        validate_list_of_strings,
+    ),
+    # BuildEnv
+    # PythonEnv
+    ConfigCliMap(
+        "dependency_file_path",
+        "build_env.python_env.dependency_file_path",
+        validate_string,
+    ),
+    # DockerConf
+    ConfigCliMap("base_image", "build_env.docker.base_image", validate_string),
+    ConfigCliMap("param_list", "build_env.docker.params", validate_list_of_strings),
+    ConfigCliMap("env_vars", "build_env.docker.env_vars", validate_list_of_strings),
+    ConfigCliMap("cache", "build_env.docker.cache", validate_bool),
+    ConfigCliMap("push", "build_env.docker.push", validate_bool),
+    ConfigCliMap(
+        "iam_role_arn", "build_env.docker.assumed_iam_role_arn", validate_string
+    ),
+    ConfigCliMap(
+        "service_account_key_secret_name",
+        "build_env.docker.service_account_key_secret_name",
+        validate_string,
+    ),
+    # RemoteConf
+    ConfigCliMap("cpus", "build_env.remote.resources.cpus", validate_float),
+    ConfigCliMap("memory", "build_env.remote.resources.memory", validate_string),
+    ConfigCliMap("gpu_type", "build_env.remote.resources.gpu_type", validate_string),
+    ConfigCliMap(
+        "gpu_amount", "build_env.remote.resources.gpu_amount", validate_positive_int
+    ),
+    ConfigCliMap("instance", "build_env.remote.resources.instance", validate_string),
+    # Verbosity level
+    ConfigCliMap("verbose", "verbose", validate_int),
+    ConfigCliMap("deploy", "deploy", validate_bool),
+    ConfigCliMap("deployment_instance", "deployment_instance", validate_string),
+    ConfigCliMap("purchase_option", "purchase_option", validate_purchase_option),
+    ConfigCliMap(
+        "provision_instance_timeout",
+        "provision_instance_timeout",
+        validate_positive_int,
+    ),
+]
+
+
+@protobuf_factory(Step)
+@dataclass
+class Step:
+    validate_build_artifact: bool = field(default=True)
+    validate_build_artifact_timeout: int = field(default=120)
+    tests: bool = field(default=True)
+
+
+@protobuf_factory(
+    BuildModelUri,
+    exclude_fields=[
+        "git_credentials",
+        "git_credentials_secret",
+        "dependency_required_folders",
+    ],
+)
+@dataclass
+class ModelUri:
+    uri: Optional[str] = field(default=None)
+    git_branch: Optional[str] = field(default="master")
+    main_dir: Optional[str] = field(default="main")
+    dependency_required_folders: List[str] = field(default_factory=list)
+    git_credentials: Optional[str] = field(default=None)
+    git_credentials_secret: Optional[str] = field(default=None)
+    git_secret_ssh: Optional[str] = field(default=None)
+
+
+@protobuf_factory(BuildPropertiesProto)
+@dataclass
+class BuildProperties:
+    build_id: Optional[str] = field(default=None)
+    gpu_compatible: bool = field(default=False)
+    branch: Optional[str] = field(default="main")
+    model_id: str = field(default="")
+    tags: List[str] = field(default_factory=list)
+    model_uri: ModelUri = field(default_factory=ModelUri)
+    build_name: Optional[str] = field(default="")
+
+
+@protobuf_factory(DockerBuild)
+@dataclass
+class DockerConf:
+    base_image: Optional[str] = field(default=None)
+    env_vars: Optional[Union[List[str], Dict[str, str], Tuple]] = field(
+        default_factory=list
+    )
+    assumed_iam_role_arn: str = field(default=None)
+    service_account_key_secret_name: str = field(default=None)
+    params: Optional[List[str]] = field(default_factory=list)
+    no_cache: bool = field(default=False)
+    cache: bool = field(default=True)
+    push: bool = field(default=True)
+
+    def __post_init__(self):
+        if isinstance(self.env_vars, (list, tuple)):
+            self.env_vars = [expandvars(var) for var in self.env_vars]
+
+
+@protobuf_factory(VirtualEnvironmentBuild)
+@dataclass
+class VirtualenvType:
+    python_version: Optional[str] = field(default=None)
+    requirements_txt: Optional[str] = field(default=None)
+
+
+@protobuf_factory(PoetryBuild)
+@dataclass
+class PoetryType:
+    python_version: Optional[str] = field(default=None)
+    lock_file: Optional[str] = field(default=None)
+
+
+@protobuf_factory(CondaBuild)
+@dataclass
+class CondaType:
+    conda_file: Optional[str] = field(default=None)
+
+
+@protobuf_factory(
+    PythonBuild, exclude_fields=["git_credentials_secret", "git_credentials"]
+)
+@dataclass
+class PythonEnv:
+    git_credentials: Optional[str] = field(default=None)
+    git_credentials_secret: Optional[str] = field(default=None)
+    poetry: PoetryType = field(default=None)
+    conda: CondaType = field(default=None)
+    virtualenv: VirtualenvType = field(default=None)
+    dependency_file_path: Optional[str] = field(default=None)
+
+    def __post_init__(self):
+        if not (self.poetry or self.conda or self.virtualenv):
+            self.conda = CondaType("conda.yml")
+
+
+@protobuf_factory(RemoteBuildResourcesProto)
+@dataclass
+class RemoteBuildResources:
+    cpus: Optional[float] = field(default=None)
+    memory: Optional[str] = field(default=None)
+    gpu_type: Optional[str] = field(default=None)
+    gpu_amount: Optional[int] = field(default=None)
+    instance: Optional[str] = field(default=None)
+
+
+@protobuf_factory(RemoteBuild)
+@dataclass
+class RemoteConf:
+    is_remote: bool = field(default=True)
+    resources: RemoteBuildResources = field(default_factory=RemoteBuildResources)
+
+
+@protobuf_factory(BuildEnvironment)
+@dataclass
+class BuildEnv:
+    docker: DockerConf = field(default_factory=DockerConf)
+    python_env: PythonEnv = field(default_factory=PythonEnv)
+    remote: RemoteConf = field(default_factory=RemoteConf)
+
+
+@protobuf_factory(BuildConfiguration, exclude_fields=["deploy"])
+@dataclass
+class BuildConfigV1(YamlConfigMixin, FrogmlConfigBase):
+    @property
+    def _config_mapping(self) -> List[ConfigCliMap]:
+        return CONFIG_MAPPING
+
+    build_properties: BuildProperties = field(default_factory=BuildProperties)
+    build_env: Optional[BuildEnv] = field(default_factory=BuildEnv)
+    pre_build: Optional[BuildEnv] = field(default=None)
+    post_build: Optional[BuildEnv] = field(default=None)
+    step: Step = field(default_factory=Step)
+    deploy: bool = field(default=False)
+    deployment_instance: Optional[str] = field(default=None)
+    purchase_option: Optional[str] = field(default=None)
+    provision_instance_timeout: Optional[int] = field(default=None)
+    verbose: int = field(default=0)
+    pre_built_model: Optional[BaseModel] = field(default=None, init=False)
+
+    def _post_merge_cli(self):
+        """Implementing post merge actions."""
+        self.build_properties.model_id = self.build_properties.model_id.lower()
+        self.build_properties.tags = list(self.build_properties.tags)
+        self.build_properties.model_uri.dependency_required_folders = list(
+            self.build_properties.model_uri.dependency_required_folders
+        )
+        self.build_env.docker.env_vars = list(self.build_env.docker.env_vars)
+        self.build_env.docker.params = list(self.build_env.docker.params)
+
+    def fetch_base_docker_image_name(
+        self,
+        build_orchestrator: BuildOrchestratorClient,
+        instance_template: InstanceTemplateManagementClient,
+    ):
+        if not self.build_env.docker.base_image:
+            is_gpu_used = (
+                self.build_env.remote.resources.gpu_type
+                and self.build_env.remote.resources.gpu_amount
+                and self.build_env.remote.resources.gpu_amount > 0
+            )
+
+            if self.build_env.remote.resources.instance and not is_gpu_used:
+                is_gpu_used = self.deduce_gpu_from_template(instance_template)
+
+            if is_gpu_used or self.build_properties.gpu_compatible:
+                result = build_orchestrator.fetch_base_docker_image_name(
+                    BaseDockerImageType.GPU
+                )
+                self.build_env.docker.base_image = result.base_docker_image_name
+            else:
+                result = build_orchestrator.fetch_base_docker_image_name(
+                    BaseDockerImageType.CPU
+                )
+                self.build_env.docker.base_image = result.base_docker_image_name
+
+    def deduce_gpu_from_template(self, instance_template):
+        try:
+            instance_spec = instance_template.get_instance_template(
+                self.build_env.remote.resources.instance
+            )
+            return instance_spec.instance_type == InstanceType.INSTANCE_TYPE_GPU
+
+        except FrogmlException as e:
+            if not e.status_code or e.status_code != grpc.StatusCode.NOT_FOUND:
+                raise e

core/inner/build_logic/build_loggers/trigger_build_logger.py

@@ -0,0 +1,50 @@
+import logging
+from logging import Logger
+
+from frogml.core.inner.build_logic.interface.build_logger_interface import BuildLogger
+from frogml.core.inner.build_logic.interface.build_phase import BuildPhase
+
+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 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}")

core/inner/build_logic/execute_build_pipeline.py

@@ -0,0 +1,64 @@
+from frogml.core.exceptions import (
+    FrogmlGeneralBuildException,
+    FrogmlRemoteBuildFailedException,
+)
+from frogml.core.inner.build_logic.interface.phase_run_handler import PhaseRunHandler
+from frogml.core.inner.build_logic.interface.time_source import (
+    Stopwatch,
+    SystemClockTimeSource,
+    TimeSource,
+)
+from frogml.core.inner.build_logic.phases.phases_pipeline import PhasesPipeline
+
+
+def execute_build_pipeline(
+    pipeline: PhasesPipeline,
+    phase_run_handler: PhaseRunHandler,
+):
+    time_source = SystemClockTimeSource()
+    for phase in pipeline.phases:
+        with phase_run_handler.handle_current_phase(phase):
+            phase_run(phase, phase_run_handler, time_source)
+
+
+def phase_run(
+    phase: PhasesPipeline,
+    phase_run_handler: PhaseRunHandler,
+    time_source: TimeSource,
+):
+    build_id = phase.context.build_id
+    current_step_phase = None
+    stop_watch = Stopwatch(time_source)
+    try:
+        for step in phase.steps:
+            current_step_phase = step.build_phase
+            step.set_logger(phase_run_handler.build_logger)
+            phase_run_handler.handle_phase_in_progress(current_step_phase)
+
+            step.execute()
+
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        phase_run_handler.handle_phase_finished_successfully(
+            current_step_phase, phase_duration
+        )
+    except FrogmlGeneralBuildException as e:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        phase_run_handler.handle_contact_support_error(
+            build_id, current_step_phase, e, phase_duration
+        )
+    except FrogmlRemoteBuildFailedException as e:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        phase_run_handler.handle_remote_build_error(
+            build_id, current_step_phase, e, phase_duration
+        )
+    except KeyboardInterrupt:
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        phase_run_handler.handle_keyboard_interrupt(
+            build_id, current_step_phase, phase_duration
+        )
+    except BaseException as e:
+        phase_run_handler.build_logger.exception("Failed", e)
+        phase_duration = stop_watch.elapsed_time_in_seconds()
+        phase_run_handler.handle_pipeline_exception(
+            build_id, current_step_phase, e, phase_duration
+        )