snowflake-ml-python 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

snowflake/ml/model/_deploy_client/image_builds/docker_context.py

@@ -0,0 +1,89 @@
+import importlib
+import os
+import shutil
+import string
+from abc import ABC
+
+from snowflake.ml.model._deploy_client.utils import constants
+
+
+class DockerContext(ABC):
+    """
+    Constructs the Docker context directory required for image building.
+    """
+
+    def __init__(self, context_dir: str, model_dir: str, *, use_gpu: bool = False) -> None:
+        """Initialization
+
+        Args:
+            context_dir: Path to context directory.
+            model_dir: Path to local model directory.
+            use_gpu: Boolean flag for generating the CPU or GPU base image.
+        """
+        self.context_dir = context_dir
+        self.model_dir = model_dir
+        # TODO(shchen): SNOW-825995, Define dockerfile template used for model deployment. use_gpu will be used.
+        self.use_gpu = use_gpu
+
+    def build(self) -> None:
+        """
+        Generates and/or moves resources into the Docker context directory.Rename the random model directory name to
+        constant "model_dir" instead for better readability.
+        """
+        self._generate_inference_code()
+        self._copy_entrypoint_script_to_docker_context()
+        self._copy_snowml_source_code_to_docker_context()
+        self._generate_docker_file()
+
+    def _copy_snowml_source_code_to_docker_context(self) -> None:
+        """Copy the entire snowflake/ml source code to docker context. This will be particularly useful for CI tests
+        against latest changes.
+
+        Note that we exclude the experimental directory mainly for development scenario; as experimental directory won't
+        be included in the release.
+        """
+        snow_ml_source_dir = list(importlib.import_module("snowflake.ml").__path__)[0]
+        shutil.copytree(
+            snow_ml_source_dir,
+            os.path.join(self.context_dir, "snowflake", "ml"),
+            ignore=shutil.ignore_patterns("*.pyc", "experimental"),
+        )
+
+    def _copy_entrypoint_script_to_docker_context(self) -> None:
+        """Copy gunicorn_run.sh entrypoint to docker context directory."""
+        path = os.path.join(os.path.dirname(__file__), constants.ENTRYPOINT_SCRIPT)
+        assert os.path.exists(path), f"Run script file missing at path: {path}"
+        shutil.copy(path, os.path.join(self.context_dir, constants.ENTRYPOINT_SCRIPT))
+
+    def _generate_docker_file(self) -> None:
+        """
+        Generates dockerfile based on dockerfile template.
+        """
+        docker_file_path = os.path.join(self.context_dir, "Dockerfile")
+        docker_file_template = os.path.join(os.path.dirname(__file__), "templates/dockerfile_template")
+
+        with open(docker_file_path, "w", encoding="utf-8") as dockerfile, open(
+            docker_file_template, encoding="utf-8"
+        ) as template:
+            dockerfile_content = string.Template(template.read()).safe_substitute(
+                {
+                    # TODO(shchen): SNOW-835411, Support overwriting base image
+                    "base_image": "mambaorg/micromamba:focal-cuda-11.7.1"
+                    if self.use_gpu
+                    else "mambaorg/micromamba:1.4.3",
+                    "model_dir": constants.MODEL_DIR,
+                    "inference_server_dir": constants.INFERENCE_SERVER_DIR,
+                    "entrypoint_script": constants.ENTRYPOINT_SCRIPT,
+                }
+            )
+            dockerfile.write(dockerfile_content)
+
+    def _generate_inference_code(self) -> None:
+        """
+        Generates inference code based on the app template and creates a folder named 'server' to house the inference
+        server code.
+        """
+        inference_server_folder_path = os.path.join(os.path.dirname(__file__), constants.INFERENCE_SERVER_DIR)
+        destination_folder_path = os.path.join(self.context_dir, constants.INFERENCE_SERVER_DIR)
+        ignore_patterns = shutil.ignore_patterns("BUILD.bazel", "*test.py", "*.\\.*", "__pycache__")
+        shutil.copytree(inference_server_folder_path, destination_folder_path, ignore=ignore_patterns)

snowflake/ml/model/_deploy_client/image_builds/gunicorn_run.sh

@@ -0,0 +1,24 @@
+#!/bin/sh
+set -eu
+
+OS=$(uname)
+
+if [ "${OS}" = "Linux" ]; then
+    NUM_CORES=$(nproc)
+elif [ "${OS}" = "Darwin" ]; then
+    # macOS
+    NUM_CORES=$(sysctl -n hw.ncpu)
+elif [ "${OS}" = "Windows" ]; then
+    NUM_CORES=$(wmic cpu get NumberOfCores | grep -Eo '[0-9]+')
+else
+    echo "Unsupported operating system: ${OS}"
+    exit 1
+fi
+
+# Based on the Gunicorn documentation, set the number of workers to number_of_cores * 2 + 1. This assumption is
+# based on an ideal scenario where one core is handling two processes simultaneously, while one process is dedicated to
+# IO operations and the other process is performing compute tasks.
+NUM_WORKERS=$((NUM_CORES * 2 + 1))
+echo "Number of CPU cores: $NUM_CORES"
+echo "Setting number of workers to $NUM_WORKERS"
+exec /opt/conda/bin/gunicorn --preload -w "$NUM_WORKERS" -k uvicorn.workers.UvicornWorker -b 0.0.0.0:5000 inference_server.main:app

snowflake/ml/model/_deploy_client/image_builds/inference_server/main.py

@@ -0,0 +1,118 @@
+import logging
+import os
+import tempfile
+import zipfile
+
+import pandas as pd
+from starlette import applications, requests, responses, routing
+
+logger = logging.getLogger(__name__)
+loaded_model = None
+
+
+def _run_setup() -> None:
+    """Set up logging and load model into memory."""
+    # Align the application logger's handler with Gunicorn's to capture logs from all processes.
+    gunicorn_logger = logging.getLogger("gunicorn.error")
+    logger.handlers = gunicorn_logger.handlers
+    logger.setLevel(gunicorn_logger.level)
+
+    from snowflake.ml.model import _model as model_api
+
+    global loaded_model
+
+    MODEL_ZIP_STAGE_PATH = os.getenv("MODEL_ZIP_STAGE_PATH")
+    assert MODEL_ZIP_STAGE_PATH, "Missing environment variable MODEL_ZIP_STAGE_PATH"
+    root_path = os.path.abspath(os.sep)
+    model_zip_stage_path = os.path.join(root_path, MODEL_ZIP_STAGE_PATH)
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        if zipfile.is_zipfile(model_zip_stage_path):
+            extracted_dir = os.path.join(tmp_dir, "extracted_model_dir")
+            logger.info(f"Extracting model zip from {model_zip_stage_path} to {extracted_dir}")
+            with zipfile.ZipFile(model_zip_stage_path, "r") as model_zip:
+                if len(model_zip.namelist()) > 1:
+                    model_zip.extractall(extracted_dir)
+        else:
+            raise RuntimeError(f"No model zip found at stage path: {model_zip_stage_path}")
+        logger.info(f"Loading model from {extracted_dir} into memory")
+        loaded_model, _ = model_api._load_model_for_deploy(model_dir_path=extracted_dir)
+        logger.info("Successfully loaded model into memory")
+
+
+async def ready(request: requests.Request) -> responses.JSONResponse:
+    """Endpoint to check if the application is ready."""
+    return responses.JSONResponse({"status": "ready"})
+
+
+async def predict(request: requests.Request) -> responses.JSONResponse:
+    """Endpoint to make predictions based on input data.
+
+    Args:
+        request: The input data is expected to be in the following JSON format:
+            {
+                "data": [
+                    [0, 5.1, 3.5, 4.2, 1.3],
+                    [1, 4.7, 3.2, 4.1, 4.2]
+            }
+            Each row is represented as a list, where the first element denotes the index of the row.
+
+    Returns:
+        Two possible responses:
+        For success, return a JSON response {"data": [[0, 1], [1, 2]]}, where the first element of each resulting list
+            denotes the index of the row, and the rest of the elements represent the prediction results for that row.
+        For an error, return {"error": error_message, "status_code": http_response_status_code}.
+    """
+    try:
+        input = await request.json()
+        assert "data" in input, "missing data field in the request input"
+        # The expression x[1:] is used to exclude the index of the data row.
+        input_data = [x[1:] for x in input.get("data")]
+        x = pd.DataFrame(input_data)
+        assert len(input_data) != 0 and not all(not row for row in input_data), "empty data"
+    except Exception as e:
+        error_message = f"Input data malformed: {str(e)}"
+        return responses.JSONResponse({"error": error_message}, status_code=400)
+
+    assert loaded_model
+
+    try:
+        # TODO(shchen): SNOW-835369, Support target method in inference server (Multi-task model).
+        # Mypy ignore will be fixed along with the above ticket.
+        predictions = loaded_model.predict(x)  # type: ignore[attr-defined]
+        result = predictions.to_records(index=True).tolist()
+        response = {"data": result}
+        return responses.JSONResponse(response)
+    except Exception as e:
+        error_message = f"Prediction failed: {str(e)}"
+        return responses.JSONResponse({"error": error_message}, status_code=400)
+
+
+def _in_test_mode() -> bool:
+    """Check if the code is running in test mode.
+
+    Specifically, it checks for the presence of
+    - "PYTEST_CURRENT_TEST" environment variable, which is automatically set by Pytest when running tests, and
+    - "TEST_WORKSPACE" environment variable, which is set by Bazel test, and
+    - "TEST_SRCDIR" environment variable, which is set by the Absl test.
+
+    Returns:
+        True if in test mode; otherwise, returns False
+    """
+    is_running_under_py_test = "PYTEST_CURRENT_TEST" in os.environ
+    is_running_under_bazel_test = "TEST_WORKSPACE" in os.environ
+    is_running_under_absl_test = "TEST_SRCDIR" in os.environ
+    return is_running_under_py_test or is_running_under_bazel_test or is_running_under_absl_test
+
+
+def run_app() -> applications.Starlette:
+    if not _in_test_mode():
+        _run_setup()
+    routes = [
+        routing.Route("/health", endpoint=ready, methods=["GET"]),
+        routing.Route("/predict", endpoint=predict, methods=["POST"]),
+    ]
+    return applications.Starlette(routes=routes)
+
+
+app = run_app()

snowflake/ml/model/_deploy_client/image_builds/templates/dockerfile_template

@@ -0,0 +1,40 @@
+FROM $base_image as build
+
+COPY $model_dir/env/conda.yaml conda.yaml
+COPY $model_dir/env/requirements.txt requirements.txt
+
+# Set MAMBA_DOCKERFILE_ACTIVATE=1 to activate the conda environment during build time.
+ARG MAMBA_DOCKERFILE_ACTIVATE=1
+
+# The micromamba image comes with an empty environment named base.
+RUN --mount=type=cache,target=/opt/conda/pkgs micromamba install -y -n base -f conda.yaml && \
+	python -m pip install "uvicorn[standard]" gunicorn starlette && \
+	python -m pip install -r requirements.txt
+
+FROM debian:buster-slim AS runtime
+
+ENV USER nonrootuser
+ENV UID 1000
+ENV HOME /home/$USER
+RUN adduser --disabled-password \
+	--gecos "A non-root user for running inference server" \
+	--uid $UID \
+	--home $HOME \
+	$USER
+
+COPY $inference_server_dir ./$inference_server_dir
+COPY $entrypoint_script ./$entrypoint_script
+RUN chmod +x /$entrypoint_script
+ # Copy Snowflake/ml source code
+# TODO: not needed as source code is either in model, or pulled from conda
+COPY snowflake ./snowflake
+
+# The mamba root prefix by default is set to /opt/conda, in which the base conda environment is built at.
+COPY --from=build /opt/conda /opt/conda
+
+# Expose the port on which the Starlette app will run.
+EXPOSE 5000
+
+USER nonrootuser
+
+CMD ["/$entrypoint_script"]

snowflake/ml/model/_deploy_client/snowservice/deploy.py

@@ -0,0 +1,199 @@
+import logging
+import os
+import posixpath
+import string
+import tempfile
+from abc import ABC
+from typing import Any, Dict, cast
+
+from typing_extensions import Unpack
+
+from snowflake.ml.model._deploy_client.image_builds import (
+    base_image_builder,
+    client_image_builder,
+)
+from snowflake.ml.model._deploy_client.snowservice import deploy_options
+from snowflake.ml.model._deploy_client.utils import constants, snowservice_client
+from snowflake.snowpark import Session
+
+
+def _deploy(
+    session: Session,
+    *,
+    model_id: str,
+    service_func_name: str,
+    model_zip_stage_path: str,
+    **kwargs: Unpack[deploy_options.SnowServiceDeployOptionsTypedHint],
+) -> None:
+    """Entrypoint for model deployment to SnowService. This function will trigger a docker image build followed by
+    workflow deployment to SnowService.
+
+    Args:
+        session: Snowpark session
+        model_id: Unique hex string of length 32, provided by model registry.
+        service_func_name: The service function name in SnowService associated with the created service.
+        model_zip_stage_path: Path to model zip file in stage. Note that this path has a "@" prefix.
+        **kwargs: various SnowService deployment options.
+
+    Raises:
+        ValueError: Raised when model_id is empty.
+        ValueError: Raised when service_func_name is empty.
+        ValueError: Raised when model_stage_file_path is empty.
+    """
+    snowpark_logger = logging.getLogger("snowflake.snowpark")
+    snowflake_connector_logger = logging.getLogger("snowflake.connector")
+    snowpark_log_level = snowpark_logger.level
+    snowflake_connector_log_level = snowflake_connector_logger.level
+    try:
+        # Setting appropriate log level to prevent console from being polluted by vast amount of snowpark and snowflake
+        # connector logging.
+        snowpark_logger.setLevel(logging.WARNING)
+        snowflake_connector_logger.setLevel(logging.WARNING)
+        if not model_id:
+            raise ValueError('Must provide a non-empty string for "model_id" when deploying to SnowService')
+        if not service_func_name:
+            raise ValueError('Must provide a non-empty string for "service_func_name" when deploying to SnowService')
+        if not model_zip_stage_path:
+            raise ValueError(
+                'Must provide a non-empty string for "model_stage_file_path" when deploying to SnowService'
+            )
+        assert model_zip_stage_path.startswith("@"), f"stage path should start with @, actual: {model_zip_stage_path}"
+        options = deploy_options.SnowServiceDeployOptions.from_dict(cast(Dict[str, Any], kwargs))
+        image_builder = client_image_builder.ClientImageBuilder(
+            id=model_id, image_repo=options.image_repo, model_zip_stage_path=model_zip_stage_path, session=session
+        )
+        ss_deployment = SnowServiceDeployment(
+            session=session,
+            model_id=model_id,
+            service_func_name=service_func_name,
+            model_zip_stage_path=model_zip_stage_path,
+            image_builder=image_builder,
+            options=options,
+        )
+        ss_deployment.deploy()
+    finally:
+        # Preserve the original logging level.
+        snowpark_logger.setLevel(snowpark_log_level)
+        snowflake_connector_logger.setLevel(snowflake_connector_log_level)
+
+
+class SnowServiceDeployment(ABC):
+    """
+    Class implementation that encapsulates image build and workflow deployment to SnowService
+
+    #TODO[shchen], SNOW-830093 GPU support on model deployment to SnowService
+    """
+
+    def __init__(
+        self,
+        session: Session,
+        model_id: str,
+        service_func_name: str,
+        model_zip_stage_path: str,
+        image_builder: base_image_builder.ImageBuilder,
+        options: deploy_options.SnowServiceDeployOptions,
+    ) -> None:
+        """Initialization
+
+        Args:
+            session: Snowpark session
+            model_id: Unique hex string of length 32, provided by model registry; if not provided, auto-generate one for
+                        resource naming.The model_id serves as an idempotent key throughout the deployment workflow.
+            service_func_name: The service function name in SnowService associated with the created service.
+            model_zip_stage_path: Path to model zip file in stage.
+            image_builder: InferenceImageBuilder instance that handles image build and upload to image registry.
+            options: A SnowServiceDeployOptions object containing deployment options.
+        """
+
+        self.session = session
+        self.id = model_id
+        self.service_func_name = service_func_name
+        self.model_zip_stage_path = model_zip_stage_path
+        self.image_builder = image_builder
+        self.options = options
+        self._service_name = f"service_{model_id}"
+        # Spec file and future deployment related artifacts will be stored under {stage}/models/{model_id}
+        self._model_artifact_stage_location = posixpath.join(options.stage, "models", self.id)
+
+    def deploy(self) -> None:
+        """
+        This function triggers image build followed by workflow deployment to SnowService.
+        """
+        if self.options.prebuilt_snowflake_image:
+            image = self.options.prebuilt_snowflake_image
+            logging.info(f"Skipped image build. Use Snowflake prebuilt image: {self.options.prebuilt_snowflake_image}")
+        else:
+            image = self._build_and_upload_image()
+        self._deploy_workflow(image)
+
+    def _build_and_upload_image(self) -> str:
+        """This function handles image build and upload to image registry.
+
+        Returns:
+            Path to the image in the remote image repository.
+        """
+        return self.image_builder.build_and_upload_image()
+
+    def _prepare_and_upload_artifacts_to_stage(self, image: str) -> None:
+        """Constructs and upload service spec to stage.
+
+        Args:
+            image: Name of the image to create SnowService container from.
+        """
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            spec_template_path = os.path.join(os.path.dirname(__file__), "templates/service_spec_template")
+            spec_file_path = os.path.join(tempdir, f"{constants.SERVICE_SPEC}.yaml")
+
+            with open(spec_template_path, encoding="utf-8") as template, open(
+                spec_file_path, "w", encoding="utf-8"
+            ) as spec_file:
+                content = string.Template(template.read()).substitute(
+                    {
+                        "image": image,
+                        "predict_endpoint_name": constants.PREDICT,
+                        "stage": self.options.stage,
+                        "model_zip_stage_path": self.model_zip_stage_path[1:],  # Remove the @ prefix
+                        "inference_server_container_name": constants.INFERENCE_SERVER_CONTAINER,
+                    }
+                )
+                spec_file.write(content)
+                logging.info(f"Create service spec: \n {content}")
+
+            self.session.file.put(
+                local_file_name=spec_file_path,
+                stage_location=self._model_artifact_stage_location,
+                auto_compress=False,
+                overwrite=True,
+            )
+            logging.info(
+                f"Uploaded spec file {os.path.basename(spec_file_path)} " f"to {self._model_artifact_stage_location}"
+            )
+
+    def _deploy_workflow(self, image: str) -> None:
+        """This function handles workflow deployment to SnowService with the given image.
+
+        Args:
+            image: Name of the image to create SnowService container from.
+        """
+
+        self._prepare_and_upload_artifacts_to_stage(image)
+        client = snowservice_client.SnowServiceClient(self.session)
+        spec_stage_location = posixpath.join(
+            self._model_artifact_stage_location.rstrip("/"), f"{constants.SERVICE_SPEC}.yaml"
+        )
+        client.create_or_replace_service(
+            service_name=self._service_name,
+            compute_pool=self.options.compute_pool,
+            spec_stage_location=spec_stage_location,
+            min_instances=self.options.min_instances,
+            max_instances=self.options.max_instances,
+        )
+        client.block_until_resource_is_ready(
+            resource_name=self._service_name, resource_type=constants.ResourceType.SERVICE
+        )
+        client.create_or_replace_service_function(
+            service_func_name=self.service_func_name,
+            service_name=self._service_name,
+            endpoint_name=constants.PREDICT,
+        )

snowflake/ml/model/_deploy_client/snowservice/deploy_options.py

@@ -0,0 +1,88 @@
+from typing import Any, Dict, Optional, TypedDict
+
+from typing_extensions import NotRequired
+
+from snowflake.ml.model._deploy_client.utils import constants
+
+
+class SnowServiceDeployOptionsTypedHint(TypedDict):
+    """Deployment options for deploying to SnowService.
+
+    stage: the name of the stage for uploading artifacts.
+    compute_pool: SnowService compute pool name.
+    image_repo: SnowService image repo path. e.g. "<image_registry>/<db>/<schema>/<repo>"
+    min_instances: Minimum number of service replicas.
+    max_instances: Maximum number of service replicas.
+    endpoint: The specific name of the endpoint that the service function will communicate with. Default to
+                "predict". This option is useful when service has multiple endpoints.
+    overridden_base_image: When provided, it will override the base image.
+    """
+
+    stage: str
+    compute_pool: str
+    image_repo: str
+    min_instances: NotRequired[int]
+    max_instances: NotRequired[int]
+    endpoint: NotRequired[str]
+    overridden_base_image: NotRequired[str]
+
+
+class SnowServiceDeployOptions:
+    def __init__(
+        self,
+        stage: str,
+        compute_pool: str,
+        image_repo: str,
+        *,
+        min_instances: int = 1,
+        max_instances: int = 1,
+        endpoint: str = constants.PREDICT,
+        overridden_base_image: Optional[str] = None,
+        prebuilt_snowflake_image: Optional[str] = None,
+    ) -> None:
+        """Initialization
+
+        Args:
+            stage: the name of the stage for uploading artifacts.
+            compute_pool: SnowService compute pool name.
+            image_repo: SnowService image repo path. e.g. "<image_registry>/<db>/<schema>/<repo>"
+            min_instances: Minimum number of service replicas.
+            max_instances: Maximum number of service replicas.
+            endpoint: The specific name of the endpoint that the service function will communicate with. Default to
+                        "predict". This option is useful when service has multiple endpoints.
+            overridden_base_image: When provided, it will override the base image.
+            prebuilt_snowflake_image: When provided, the image building step is skipped, and the pre-built image from
+                Snowflake is used as is. This option is for users who consistently use the same image for multiple use
+                cases, allowing faster deployment. The snowflake image used for deployment is logged to the console for
+                future use.
+        """
+
+        self.stage = stage
+        self.compute_pool = compute_pool
+        self.image_repo = image_repo
+        self.min_instances = min_instances
+        self.max_instances = max_instances
+        self.endpoint = endpoint
+        self.overridden_base_image = overridden_base_image
+        self.prebuilt_snowflake_image = prebuilt_snowflake_image
+
+    @classmethod
+    def from_dict(cls, options_dict: Dict[str, Any]) -> "SnowServiceDeployOptions":
+        """Construct SnowServiceDeployOptions instance based from an option dictionary.
+
+        Args:
+            options_dict: The dict containing various deployment options.
+
+        Raises:
+            ValueError: When required option is missing.
+
+        Returns:
+            A SnowServiceDeployOptions object
+        """
+        required_options = [constants.STAGE, constants.COMPUTE_POOL, constants.IMAGE_REPO]
+        missing_keys = [key for key in required_options if options_dict.get(key) is None]
+        if missing_keys:
+            raise ValueError(f"Must provide options when deploying to SnowService: {', '.join(missing_keys)}")
+        # SnowService image repo cannot handle upper case repo name.
+        options_dict[constants.IMAGE_REPO] = options_dict[constants.IMAGE_REPO].lower()
+        return cls(**options_dict)

snowflake/ml/model/_deploy_client/snowservice/templates/service_spec_template

@@ -0,0 +1,24 @@
+spec:
+  container:
+    - name: ${inference_server_container_name}
+      image: ${image}
+      env:
+        MODEL_ZIP_STAGE_PATH: ${model_zip_stage_path}
+      readinessProbe:
+        port: 5000
+        path: /health
+      volumeMounts:
+        - name: vol1
+          mountPath: /local/user/vol1
+        - name: stage
+          mountPath: ${stage}
+  endpoint:
+    - name: ${predict_endpoint_name}
+      port: 5000
+  volume:
+    - name: vol1
+      source: local  # only local emptyDir volume is supported
+    - name: stage
+      source: "@${stage}"
+      uid: 1000
+      gid: 1000

snowflake/ml/model/_deploy_client/utils/constants.py

@@ -0,0 +1,47 @@
+from enum import Enum
+
+
+class ResourceType(Enum):
+    SERVICE = "service"
+    JOB = "job"
+
+
+"""
+Potential SnowService status based on existing ResourceSetStatus proto:
+
+github.com/snowflakedb/snowflake/blob/main/GlobalServices/src/main/protobuf/snowservices_resourceset_reconciler.proto
+"""
+
+
+class ResourceStatus(Enum):
+    UNKNOWN = "UNKNOWN"  # status is unknown because we have not received enough data from K8s yet.
+    PENDING = "PENDING"  # resource set is being created, can't be used yet
+    READY = "READY"  # resource set has been deployed.
+    DELETING = "DELETING"  # resource set is being deleted
+    FAILED = "FAILED"  # resource set has failed and cannot be used anymore
+    DONE = "DONE"  # resource set has finished running
+    NOT_FOUND = "NOT_FOUND"  # not found or deleted
+    INTERNAL_ERROR = "INTERNAL_ERROR"  # there was an internal service error.
+
+
+RESOURCE_TO_STATUS_FUNCTION_MAPPING = {
+    ResourceType.SERVICE: "SYSTEM$GET_SNOWSERVICE_STATUS",
+    ResourceType.JOB: "SYSTEM$GET_JOB_STATUS",
+}
+
+PREDICT = "predict"
+STAGE = "stage"
+COMPUTE_POOL = "compute_pool"
+IMAGE_REPO = "image_repo"
+MIN_INSTANCES = "min_instances"
+MAX_INSTANCES = "max_instances"
+GPU_COUNT = "gpu"
+OVERRIDDEN_BASE_IMAGE = "image"
+ENDPOINT = "endpoint"
+SERVICE_SPEC = "service_spec"
+INFERENCE_SERVER_CONTAINER = "inference-server"
+
+"""Image build related constants"""
+MODEL_DIR = "model_dir"
+INFERENCE_SERVER_DIR = "inference_server"
+ENTRYPOINT_SCRIPT = "gunicorn_run.sh"