snowflake-ml-python 1.6.2__py3-none-any.whl → 1.6.3__py3-none-any.whl

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

@@ -1,116 +0,0 @@
-import inspect
-import logging
-from typing import Any, Dict, List, Optional
-
-from snowflake.ml._internal.exceptions import (
-    error_codes,
-    exceptions as snowml_exceptions,
-)
-from snowflake.ml.model._deploy_client.utils import constants
-
-logger = logging.getLogger(__name__)
-
-
-class SnowServiceDeployOptions:
-    def __init__(
-        self,
-        compute_pool: str,
-        *,
-        external_access_integrations: List[str],
-        image_repo: Optional[str] = None,
-        min_instances: Optional[int] = 1,
-        max_instances: Optional[int] = 1,
-        prebuilt_snowflake_image: Optional[str] = None,
-        num_gpus: Optional[int] = 0,
-        num_workers: Optional[int] = None,
-        enable_remote_image_build: Optional[bool] = True,
-        force_image_build: Optional[bool] = False,
-        model_in_image: Optional[bool] = False,
-        debug_mode: Optional[bool] = False,
-        enable_ingress: Optional[bool] = False,
-    ) -> None:
-        """Initialization
-
-        When updated, please ensure the type hint is updated accordingly at: //snowflake/ml/model/type_hints
-
-        Args:
-            compute_pool: SnowService compute pool name. Please refer to official doc for how to create a
-                compute pool:
-                https://docs.snowflake.com/en/developer-guide/snowpark-container-services/working-with-compute-pool
-            external_access_integrations: External Access Integrations name used to build image and deploy the model.
-                Please refer to the doc for how to create an External Access Integrations: https://docs.snowflake.com/
-                developer-guide/snowpark-container-services/additional-considerations-services-jobs
-                #configuring-network-capabilities .
-                To make sure your image could be built, access to the following endpoint must be allowed.
-                docker.com:80, docker.com:443, anaconda.com:80, anaconda.com:443, anaconda.org:80, anaconda.org:443,
-                pypi.org:80, pypi.org:443
-            image_repo: SnowService image repo path. e.g. "<image_registry>/<db>/<schema>/<repo>". Default to auto
-                inferred based on session information.
-            min_instances: Minimum number of service replicas. Default to 1.
-            max_instances: Maximum number of service replicas. Default to 1.
-            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. Default to None.
-            num_gpus: Number of GPUs to be used for the service. Default to 0.
-            num_workers: Number of workers used for model inference. Please ensure that the number of workers is set
-                lower than the total available memory divided by the size of model to prevent memory-related issues.
-                Default is number of CPU cores * 2 + 1.
-            enable_remote_image_build: When set to True, will enable image build on a remote SnowService job.
-                Default is True.
-            force_image_build: When set to True, an image rebuild will occur. The default is False, which means the
-                system will automatically check whether a previously built image can be reused
-            model_in_image: When set to True, image would container full model weights. The default if False, which
-                means image without model weights and we do stage mount to access weights.
-            debug_mode: When set to True, deployment artifacts will be persisted in a local temp directory.
-            enable_ingress: When set to True, will expose HTTP endpoint for access to the predict method of the created
-                service. Default to False.
-        """
-
-        self.compute_pool = compute_pool
-        self.image_repo = image_repo
-        self.min_instances = min_instances
-        self.max_instances = max_instances
-        self.prebuilt_snowflake_image = prebuilt_snowflake_image
-        self.num_gpus = num_gpus
-        self.num_workers = num_workers
-        self.enable_remote_image_build = enable_remote_image_build
-        self.force_image_build = force_image_build
-        self.model_in_image = model_in_image
-        self.debug_mode = debug_mode
-        self.enable_ingress = enable_ingress
-        self.external_access_integrations = external_access_integrations
-
-        if self.num_workers is None and self.use_gpu:
-            logger.info("num_workers has been defaulted to 1 when using GPU.")
-            self.num_workers = 1
-
-    @property
-    def use_gpu(self) -> bool:
-        return self.num_gpus is not None and self.num_gpus > 0
-
-    @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:
-            SnowflakeMLException: When required option is missing.
-
-        Returns:
-            A SnowServiceDeployOptions object
-        """
-        required_options = [constants.COMPUTE_POOL]
-        missing_keys = [key for key in required_options if options_dict.get(key) is None]
-        if missing_keys:
-            raise snowml_exceptions.SnowflakeMLException(
-                error_code=error_codes.INVALID_ARGUMENT,
-                original_exception=ValueError(
-                    f"Must provide options when deploying to Snowpark Container Services: {', '.join(missing_keys)}"
-                ),
-            )
-        supported_options_keys = inspect.signature(cls.__init__).parameters.keys()
-        filtered_options = {k: v for k, v in options_dict.items() if k in supported_options_keys}
-        return cls(**filtered_options)

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

@@ -1,10 +0,0 @@
-# Snowpark Container Service GPU instance type and corresponding GPU counts.
-INSTANCE_TYPE_TO_GPU_COUNT = {
-    "GPU_3": 1,
-    "GPU_5": 1,
-    "GPU_7": 4,
-    "GPU_10": 8,
-    "GPU_NV_S": 1,
-    "GPU_NV_M": 4,
-    "GPU_NV_L": 8,
-}

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

@@ -1,28 +0,0 @@
-spec:
-  container:
-    - name: ${inference_server_container_name}
-      image: ${image}
-      env:
-        MODEL_ZIP_STAGE_PATH: ${model_zip_stage_path}
-        TARGET_METHOD: ${target_method}
-        NUM_WORKERS: ${num_workers}
-        SNOWML_USE_GPU: ${use_gpu}
-      readinessProbe:
-        port: 5000
-        path: /health
-      volumeMounts:
-        - name: vol1
-          mountPath: /local/user/vol1
-        - name: stage
-          mountPath: ${model_stage}
-  endpoint:
-    - name: ${predict_endpoint_name}
-      port: 5000
-      public: ${enable_ingress}
-  volume:
-    - name: vol1
-      source: local  # only local emptyDir volume is supported
-    - name: stage
-      source: "@${model_stage}"
-      uid: 1000
-      gid: 1000

snowflake/ml/model/_deploy_client/snowservice/templates/service_spec_template_with_model

@@ -1,21 +0,0 @@
-spec:
-  container:
-    - name: ${inference_server_container_name}
-      image: ${image}
-      env:
-        TARGET_METHOD: ${target_method}
-        NUM_WORKERS: ${num_workers}
-        SNOWML_USE_GPU: ${use_gpu}
-      readinessProbe:
-        port: 5000
-        path: /health
-      volumeMounts:
-        - name: vol1
-          mountPath: /local/user/vol1
-  endpoint:
-    - name: ${predict_endpoint_name}
-      port: 5000
-      public: ${enable_ingress}
-  volume:
-    - name: vol1
-      source: local  # only local emptyDir volume is supported

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

@@ -1,48 +0,0 @@
-from enum import Enum
-
-
-class ResourceType(Enum):
-    SERVICE = "service"
-    JOB = "job"
-
-
-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.
-
-
-PREDICT = "predict"
-STAGE = "stage"
-COMPUTE_POOL = "compute_pool"
-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"""
-SNOWML_IMAGE_REPO = "snowml_repo"
-MODEL_DIR = "model_dir"
-INFERENCE_SERVER_DIR = "inference_server"
-ENTRYPOINT_SCRIPT = "gunicorn_run.sh"
-PROD_IMAGE_REGISTRY_DOMAIN = "snowflakecomputing.com"
-PROD_IMAGE_REGISTRY_SUBDOMAIN = "registry"
-DEV_IMAGE_REGISTRY_SUBDOMAIN = "registry-dev"
-MODEL_ENV_FOLDER = "env"
-CONDA_FILE = "conda.yml"
-IMAGE_BUILD_JOB_SPEC_TEMPLATE = "image_build_job_spec_template"
-KANIKO_SHELL_SCRIPT_TEMPLATE = "kaniko_shell_script_template"
-CONTEXT = "context"
-KANIKO_SHELL_SCRIPT_NAME = "kaniko_shell_script_fixture.sh"
-KANIKO_CONTAINER_NAME = "kaniko"
-LATEST_IMAGE_TAG = "latest"
-KANIKO_IMAGE = "kaniko-project/executor:v1.16.0-debug"
-SPCS_MOUNTED_TOKEN_PATH = "/snowflake/session/token"

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

@@ -1,280 +0,0 @@
-import json
-import logging
-import textwrap
-import time
-from typing import List, Optional
-
-from snowflake.ml._internal.exceptions import (
-    error_codes,
-    exceptions as snowml_exceptions,
-)
-from snowflake.ml._internal.utils import log_stream_processor, uri
-from snowflake.ml.model._deploy_client.utils import constants
-from snowflake.snowpark import Session
-
-logger = logging.getLogger(__name__)
-
-
-class SnowServiceClient:
-    """
-    SnowService client implementation: a Python wrapper for SnowService SQL queries.
-    """
-
-    def __init__(self, session: Session) -> None:
-        """Initialization
-
-        Args:
-            session: Snowpark session
-        """
-        self.session = session
-
-    def create_image_repo(self, repo_name: str) -> None:
-        self.session.sql(f"CREATE IMAGE REPOSITORY IF NOT EXISTS {repo_name}").collect()
-
-    def create_or_replace_service(
-        self,
-        service_name: str,
-        compute_pool: str,
-        spec_stage_location: str,
-        external_access_integrations: List[str],
-        *,
-        min_instances: Optional[int] = 1,
-        max_instances: Optional[int] = 1,
-    ) -> None:
-        """Create or replace service. Since SnowService doesn't support the CREATE OR REPLACE service syntax, we will
-        first attempt to drop the service if it exists, and then create the service. Please note that this approach may
-        have side effects due to the lack of transaction support.
-
-        Args:
-            service_name: Name of the service.
-            min_instances: Minimum number of service replicas.
-            max_instances: Maximum number of service replicas.
-            external_access_integrations: EAIs for network connection.
-            compute_pool: Name of the compute pool.
-            spec_stage_location: Stage path for the service spec.
-        """
-        stage, path = uri.get_stage_and_path(spec_stage_location)
-        self._drop_service_if_exists(service_name)
-        sql = textwrap.dedent(
-            f"""
-             CREATE SERVICE {service_name}
-                IN COMPUTE POOL {compute_pool}
-                FROM {stage}
-                SPEC = '{path}'
-                MIN_INSTANCES={min_instances}
-                MAX_INSTANCES={max_instances}
-                EXTERNAL_ACCESS_INTEGRATIONS = ({', '.join(external_access_integrations)})
-            """
-        )
-        logger.info(f"Creating service {service_name}")
-        logger.debug(f"Create service with SQL: \n {sql}")
-        self.session.sql(sql).collect()
-
-    def create_job(
-        self, job_name: str, compute_pool: str, spec_stage_location: str, external_access_integrations: List[str]
-    ) -> None:
-        """Execute the job creation SQL command. Note that the job creation is synchronous, hence we execute it in a
-        async way so that we can query the log in the meantime.
-
-        Upon job failure, full job container log will be logged.
-
-        Args:
-            job_name: name of the job
-            compute_pool: name of the compute pool
-            spec_stage_location: path to the stage location where the spec is located at.
-            external_access_integrations: EAIs for network connection.
-        """
-        stage, path = uri.get_stage_and_path(spec_stage_location)
-        sql = textwrap.dedent(
-            f"""
-            EXECUTE JOB SERVICE
-            IN COMPUTE POOL {compute_pool}
-            FROM {stage}
-            SPECIFICATION_FILE = '{path}'
-            NAME = {job_name}
-            EXTERNAL_ACCESS_INTEGRATIONS = ({', '.join(external_access_integrations)})
-            """
-        )
-        logger.debug(f"Create job with SQL: \n {sql}")
-        self.session.sql(sql).collect_nowait()
-        self.block_until_resource_is_ready(
-            resource_name=job_name,
-            resource_type=constants.ResourceType.JOB,
-            container_name=constants.KANIKO_CONTAINER_NAME,
-            max_retries=240,
-            retry_interval_secs=15,
-        )
-
-    def _drop_service_if_exists(self, service_name: str) -> None:
-        """Drop service if it already exists.
-
-        Args:
-            service_name: Name of the service.
-        """
-        self.session.sql(f"DROP SERVICE IF EXISTS {service_name}").collect()
-
-    def create_or_replace_service_function(
-        self,
-        service_func_name: str,
-        service_name: str,
-        *,
-        endpoint_name: str = constants.PREDICT,
-        path_at_service_endpoint: str = constants.PREDICT,
-        max_batch_rows: Optional[int] = None,
-    ) -> str:
-        """Create or replace service function.
-
-        Args:
-            service_func_name: Name of the service function.
-            service_name: Name of the service.
-            endpoint_name: Name the service endpoint, declared in the service spec, indicating the listening port.
-            path_at_service_endpoint: Specify the path/route at the service endpoint. Multiple paths can exist for a
-                given endpoint. For example, an inference server listening on port 5000 may have paths like "/predict"
-                and "/monitoring
-            max_batch_rows: Specify the MAX_BATCH_ROWS property of the service function, if None, leave unset
-
-        Returns:
-            The actual SQL for service function creation.
-        """
-        max_batch_rows_sql = ""
-        if max_batch_rows:
-            max_batch_rows_sql = f"MAX_BATCH_ROWS = {max_batch_rows}"
-
-        sql = textwrap.dedent(
-            f"""
-            CREATE OR REPLACE FUNCTION {service_func_name}(input OBJECT)
-                RETURNS OBJECT
-                SERVICE={service_name}
-                ENDPOINT={endpoint_name}
-                {max_batch_rows_sql}
-                AS '/{path_at_service_endpoint}'
-            """
-        )
-        logger.debug(f"Create service function with SQL: \n {sql}")
-        self.session.sql(sql).collect()
-        logger.debug(f"Successfully created service function: {service_func_name}")
-        return sql
-
-    def block_until_resource_is_ready(
-        self,
-        resource_name: str,
-        resource_type: constants.ResourceType,
-        *,
-        max_retries: int = 180,
-        container_name: str = constants.INFERENCE_SERVER_CONTAINER,
-        retry_interval_secs: int = 10,
-    ) -> None:
-        """Blocks execution until the specified resource is ready.
-        Note that this is a best-effort approach because when launching a service, it's possible for it to initially
-        fail due to a system error. However, SnowService may automatically retry and recover the service, leading to
-        potential false-negative information.
-
-        Args:
-            resource_name: Name of the resource.
-            resource_type: Type of the resource.
-            container_name: The container to query the log from.
-            max_retries: The maximum number of retries to check the resource readiness (default: 60).
-            retry_interval_secs: The number of seconds to wait between each retry (default: 10).
-
-        Raises:
-            SnowflakeMLException: If the resource received the following status [failed, not_found, internal_error,
-                deleting]
-            SnowflakeMLException: If the resource does not reach the ready/done state within the specified number
-                of retries.
-        """
-        assert resource_type == constants.ResourceType.SERVICE or resource_type == constants.ResourceType.JOB
-        query_command = ""
-        query_command = f"CALL SYSTEM$GET_SERVICE_LOGS('{resource_name}', '0', '{container_name}')"
-        logger.warning(
-            f"Best-effort log streaming from SPCS will be enabled when python logging level is set to INFO."
-            f"Alternatively, you can also query the logs by running the query '{query_command}'"
-        )
-        lsp = log_stream_processor.LogStreamProcessor()
-
-        for attempt_idx in range(max_retries):
-            if logger.level <= logging.INFO:
-                resource_log = self.get_resource_log(
-                    resource_name=resource_name,
-                    resource_type=resource_type,
-                    container_name=container_name,
-                )
-                lsp.process_new_logs(resource_log, log_level=logging.INFO)
-
-            status = self.get_resource_status(resource_name=resource_name)
-
-            if resource_type == constants.ResourceType.JOB and status == constants.ResourceStatus.DONE:
-                return
-            elif resource_type == constants.ResourceType.SERVICE and status == constants.ResourceStatus.READY:
-                return
-
-            if (
-                status
-                in [
-                    constants.ResourceStatus.FAILED,
-                    constants.ResourceStatus.NOT_FOUND,
-                    constants.ResourceStatus.INTERNAL_ERROR,
-                    constants.ResourceStatus.DELETING,
-                ]
-                or attempt_idx >= max_retries - 1
-            ):
-                if logger.level > logging.INFO:
-                    resource_log = self.get_resource_log(
-                        resource_name=resource_name,
-                        resource_type=resource_type,
-                        container_name=container_name,
-                    )
-                    # Show full error log when logging level is above INFO level. For INFO level and below, we already
-                    # show the log through logStreamProcessor above.
-                    logger.error(resource_log)
-
-                error_message = "failed"
-                if attempt_idx >= max_retries - 1:
-                    error_message = "does not reach ready/done status"
-
-                if resource_type == constants.ResourceType.SERVICE:
-                    self._drop_service_if_exists(service_name=resource_name)
-
-                raise snowml_exceptions.SnowflakeMLException(
-                    error_code=error_codes.INTERNAL_SNOWPARK_CONTAINER_SERVICE_ERROR,
-                    original_exception=RuntimeError(
-                        f"{resource_type} {resource_name} {error_message}." f"\nStatus: {status if status else ''} \n"
-                    ),
-                )
-            time.sleep(retry_interval_secs)
-
-    def get_resource_log(
-        self, resource_name: str, resource_type: constants.ResourceType, container_name: str
-    ) -> Optional[str]:
-        try:
-            row = self.session.sql(
-                f"CALL SYSTEM$GET_SERVICE_LOGS('{resource_name}', '0', '{container_name}')"
-            ).collect()
-            return str(row[0]["SYSTEM$GET_SERVICE_LOGS"])
-        except Exception:
-            return None
-
-    def get_resource_status(self, resource_name: str) -> Optional[constants.ResourceStatus]:
-        """Get resource status.
-
-        Args:
-            resource_name: Name of the resource.
-
-        Returns:
-            Optional[constants.ResourceStatus]: The status of the resource, or None if the resource status is empty.
-        """
-        status_func = "SYSTEM$GET_SERVICE_STATUS"
-        try:
-            row = self.session.sql(f"CALL {status_func}('{resource_name}');").collect()
-        except Exception:
-            # Silent fail as SPCS status call is not guaranteed to return in time. Will rely on caller to retry.
-            return None
-
-        resource_metadata = json.loads(row[0][status_func])[0]
-        logger.debug(f"Resource status metadata: {resource_metadata}")
-        if resource_metadata and resource_metadata["status"]:
-            try:
-                status = resource_metadata["status"]
-                return constants.ResourceStatus(status)
-            except ValueError:
-                logger.warning(f"Unknown status returned: {status}")
-        return None