frogml-cli 0.0.1__py3-none-any.whl

frogml_cli/commands/feature_store/trigger/ui.py

@@ -0,0 +1,39 @@
+import click
+from frogml._proto.qwak.feature_store.features.feature_set_service_pb2 import (
+    RunBatchFeatureSetResponse,
+)
+from frogml.core.clients.feature_store import FeatureRegistryClient
+from frogml.core.exceptions import FrogmlException
+
+from frogml_cli.inner.tools.cli_tools import FrogMLCommand
+from frogml_cli.tools.colors import Color
+
+
+@click.command(
+    "trigger", cls=FrogMLCommand, help="Trigger a batch feature set job ingestion job"
+)
+@click.argument("name")
+def trigger_feature_set(name, **kwargs):
+    """
+    Trigger a batch feature set ingestion job
+
+    Args:
+        name: Feature set name that will be triggered.
+    """
+    try:
+        result: RunBatchFeatureSetResponse = FeatureRegistryClient().run_feature_set(
+            feature_set_name=name
+        )
+    except Exception as e:
+        print(
+            f"{Color.RED} Failed to trigger a batch feature set ingestion for feature set {name} {Color.END}"
+        )
+        raise FrogmlException(
+            f"Failed to trigger a batch feature set ingestion for feature set {name}"
+        ) from e
+
+    print(
+        f"{Color.GREEN}Successfully triggered a batch feature set ingestion for feature set: {Color.YELLOW}{name}"
+    )
+    if result.execution_id:
+        print(f"{Color.WHITE} Execution ID: {Color.YELLOW}{result.execution_id}")

frogml_cli/commands/models/build/_logic/build_steps.py

@@ -0,0 +1,42 @@
+from typing import Tuple
+
+from frogml.core.inner.build_config.build_config_v1 import BuildConfigV1
+from frogml.core.inner.build_logic.interface.build_phase import BuildPhase
+from frogml.core.inner.build_logic.phases.phases_pipeline import PhasesPipeline
+from frogml.core.inner.build_logic.trigger_build_context import TriggerBuildContext
+
+from .client_logs.messages import SUCCESS_MSG_REMOTE_WITH_DEPLOY, SUCCESS_MSG_REMOTE
+from .phase.a_fetch_model_code import get_fetch_model_code_steps
+from .phase.b_remote_register_frogml_build import get_remote_register_frogml_build_steps
+from .phase.c_deploy import get_deploy_steps
+
+
+def remote_build_steps(config: BuildConfigV1) -> PhasesPipeline:
+    steps_root = PhasesPipeline(config=config, context=TriggerBuildContext())
+    steps_root.add_phase(
+        steps=get_fetch_model_code_steps(),
+        build_phase=BuildPhase(phase_id="FETCHING_MODEL_CODE"),
+    )
+    steps_root.add_phase(
+        steps=get_remote_register_frogml_build_steps(),
+        build_phase=BuildPhase(phase_id="REGISTERING_FROGML_BUILD"),
+    )
+
+    if config.deploy:
+        steps_root.add_phase(
+            steps=get_deploy_steps(),
+            build_phase=BuildPhase(phase_id="DEPLOYING_PHASE", name="Deploying", description="Deploying"),
+        )
+
+    return steps_root
+
+
+def create_pipeline(
+    config: BuildConfigV1,
+) -> Tuple[PhasesPipeline, str]:
+    success_message = (
+        SUCCESS_MSG_REMOTE_WITH_DEPLOY if config.deploy else SUCCESS_MSG_REMOTE
+    )
+    pipeline = remote_build_steps(config)
+
+    return pipeline, success_message

frogml_cli/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 frogml.core.inner.build_logic.interface.build_phase import BuildPhase
+from frogml.core.inner.build_logic.interface.phase_run_handler import PhaseRunHandler
+from frogml.core.inner.build_logic.phases.phases_pipeline import PhasesPipeline
+from yaspin import yaspin
+
+from frogml_cli.tools.colors import Color
+from .cli_trigger_build_logger import CliTriggerBuildLogger
+from .messages import (
+    FAILED_CONTACT_JFROG_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_JFROG_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)

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

@@ -0,0 +1,19 @@
+from logging import Logger
+
+from frogml.core.inner.build_logic.build_loggers.trigger_build_logger import TriggerBuildLogger
+from frogml.core.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}"

frogml_cli/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 frogml.core.inner.build_config.build_config_v1 import BuildConfigV1
+from frogml.core.inner.build_logic.constants.host_resource import HOST_FROGML_HIDDEN_FOLDER
+
+from frogml_cli import __version__ as qwak_sdk_version
+from frogml_cli.inner.tools.logger import setup_frogml_logger
+from frogml_cli.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_frogml_logger,
+    non_frogml_logger_enabled,
+    set_file_handler_log_file,
+    set_handler_verbosity,
+)
+
+BUILDS_LOGS = HOST_FROGML_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_frogml_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_frogml_logger(fallback_logger_name=fallback_logger_name)
+
+    if not non_frogml_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())

frogml_cli/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
+frogml 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_JFROG_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
+"""

frogml_cli/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

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

@@ -0,0 +1,54 @@
+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
+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}"

frogml_cli/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)

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

@@ -0,0 +1,20 @@
+from typing import List
+
+from frogml.core.inner.build_logic.interface.step_inteface import Step
+from frogml.core.inner.build_logic.phases.phase_010_fetch_model.fetch_model_step import FetchModelStep
+from frogml.core.inner.build_logic.phases.phase_010_fetch_model.post_fetch_validation_step import PostFetchValidationStep
+from frogml.core.inner.build_logic.phases.phase_010_fetch_model.pre_fetch_validation_step import PreFetchValidationStep
+
+from frogml_cli.commands.models.build._logic.phase.a_fetch_model_code.get_sdk_version_step import SdkVersionStep
+from frogml_cli.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)

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

@@ -0,0 +1,15 @@
+from frogml.core.inner.build_logic.interface.step_inteface import Step
+
+from frogml_cli import __version__ as frogml_cli_version
+from frogml_cli import __name__ as frogml_cli_name
+
+
+class SdkVersionStep(Step):
+    def description(self) -> str:
+        return "Getting SDK Version"
+
+    def execute(self) -> None:
+        self.build_logger.debug(
+            "Getting sdk version"
+        )
+        self.context.frogml_cli_version = f"{frogml_cli_name}/{frogml_cli_version}"

frogml_cli/commands/models/build/_logic/phase/b_remote_register_frogml_build/__init__.py

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

frogml_cli/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()]

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

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import time
+
+from frogml._proto.qwak.build.v1.build_api_pb2 import GetBuildResponse
+from frogml._proto.qwak.build.v1.build_pb2 import BuildStatus
+
+from frogml_cli.commands.models.build._logic.client_logs.messages import (
+    FAILED_REMOTE_BUILD_SUGGESTION,
+)
+from frogml.core.inner.build_logic.interface.step_inteface import Step
+from frogml.core.exceptions import FrogmlRemoteBuildFailedException
+
+
+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 FrogmlRemoteBuildFailedException(
+                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)

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

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import List
+
+from frogml._proto.qwak.instance_template.instance_template_pb2 import (
+    InstanceTemplateSpec,
+    InstanceType,
+)
+
+from frogml_cli.commands.models.build._logic.client_logs.messages import (
+    FAILED_DEPLOY_BUILD_SUGGESTION,
+)
+from frogml.core.inner.build_logic.interface.step_inteface import Step
+from frogml_cli.commands.models.deployments.deploy.realtime.ui import deploy_realtime
+from frogml_cli.exceptions.frogml_deploy_new_build_failed import (
+    FrogmlDeployNewBuildFailedException,
+)
+
+
+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 FrogmlDeployNewBuildFailedException(
+                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

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

@@ -0,0 +1,45 @@
+from frogml.core.exceptions import FrogmlException
+
+
+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 FrogmlException(
+                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 FrogmlException("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