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

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"

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

@@ -0,0 +1,178 @@
+import json
+import logging
+import time
+from typing import Optional
+
+from snowflake.ml.model._deploy_client.utils import constants
+from snowflake.snowpark import Session
+
+
+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_or_replace_service(
+        self,
+        service_name: str,
+        compute_pool: str,
+        spec_stage_location: str,
+        *,
+        min_instances: int = 1,
+        max_instances: 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.
+            compute_pool: Name of the compute pool.
+            spec_stage_location: Stage path for the service spec.
+        """
+        self._drop_service_if_exists(service_name)
+        sql = f"""
+             CREATE SERVICE {service_name}
+                 MIN_INSTANCES={min_instances}
+                 MAX_INSTANCES={max_instances}
+                 COMPUTE_POOL={compute_pool}
+                 SPEC=@{spec_stage_location}
+         """
+        logging.info(f"Create service with SQL: \n {sql}")
+        self.session.sql(sql).collect()
+
+    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,
+    ) -> None:
+        """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
+
+        """
+        sql = f"""
+            CREATE OR REPLACE FUNCTION {service_func_name}(input OBJECT)
+                RETURNS OBJECT
+                SERVICE={service_name}
+                ENDPOINT={endpoint_name}
+                AS '/{path_at_service_endpoint}'
+            """
+        logging.info(f"Create service function with SQL: \n {sql}")
+        self.session.sql(sql).collect()
+
+    def block_until_resource_is_ready(
+        self,
+        resource_name: str,
+        resource_type: constants.ResourceType,
+        *,
+        max_retries: int = 60,
+        retry_interval_secs: int = 5,
+    ) -> 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.
+            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: 5).
+
+        Raises:
+            RuntimeError: If the resource received the following status [failed, not_found, internal_error, deleting]
+            RuntimeError: If the resource does not reach the ready/done state within the specified number of retries.
+        """
+        for _ in range(max_retries):
+            status = self.get_resource_status(resource_name=resource_name, resource_type=resource_type)
+            if status in [constants.ResourceStatus.READY, constants.ResourceStatus.DONE]:
+                return
+            elif status in [
+                constants.ResourceStatus.FAILED,
+                constants.ResourceStatus.NOT_FOUND,
+                constants.ResourceStatus.INTERNAL_ERROR,
+                constants.ResourceStatus.DELETING,
+            ]:
+                error_log = self.get_resource_log(
+                    resource_name=resource_name,
+                    resource_type=resource_type,
+                    container_name=constants.INFERENCE_SERVER_CONTAINER,
+                )
+                raise RuntimeError(f"{resource_type} {resource_name} failed. \n {error_log if error_log else ''}")
+            time.sleep(retry_interval_secs)
+
+        raise RuntimeError("Resource never reached the ready/done state.")
+
+    def get_resource_log(
+        self, resource_name: str, resource_type: constants.ResourceType, container_name: str
+    ) -> Optional[str]:
+        if resource_type != constants.ResourceType.SERVICE:
+            raise NotImplementedError(f"{resource_type.name} is not yet supported in get_resource_log function")
+        try:
+            row = self.session.sql(
+                f"CALL SYSTEM$GET_SNOWSERVICE_LOGS('{resource_name}', '0', '{container_name}')"
+            ).collect()
+            return str(row[0]["SYSTEM$GET_SNOWSERVICE_LOGS"])
+        except Exception:
+            return None
+
+    def get_resource_status(
+        self, resource_name: str, resource_type: constants.ResourceType
+    ) -> Optional[constants.ResourceStatus]:
+        """Get resource status.
+
+        Args:
+            resource_name: Name of the resource.
+            resource_type: Type of the resource.
+
+        Raises:
+            ValueError: If resource type does not have a corresponding system function for querying status.
+            RuntimeError: If corresponding status call failed.
+
+        Returns:
+            Optional[constants.ResourceStatus]: The status of the resource, or None if the resource status is empty.
+        """
+        if resource_type not in constants.RESOURCE_TO_STATUS_FUNCTION_MAPPING:
+            raise ValueError(f"Status querying is not supported for resources of type '{resource_type}'.")
+        status_func = constants.RESOURCE_TO_STATUS_FUNCTION_MAPPING[resource_type]
+        try:
+            row = self.session.sql(f"CALL {status_func}('{resource_name}');").collect()
+        except Exception as e:
+            raise RuntimeError(f"Error while querying the {resource_type} {resource_name} status: {str(e)}")
+        resource_metadata = json.loads(row[0][status_func])[0]
+        logging.info(f"Resource status metadata: {resource_metadata}")
+        if resource_metadata and resource_metadata["status"]:
+            try:
+                status = resource_metadata["status"]
+                return constants.ResourceStatus(status)
+            except ValueError:
+                logging.warning(f"Unknown status returned: {status}")
+        return None

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

@@ -1,4 +1,5 @@
 import os
+import posixpath
 import tempfile
 import warnings
 from types import ModuleType
@@ -6,7 +7,8 @@ from typing import IO, List, Optional, Tuple, TypedDict, Union
 
 from typing_extensions import Unpack
 
-from snowflake.ml._internal import env_utils
+from snowflake.ml._internal import env_utils, file_utils
+from snowflake.ml._internal.utils import identifier
 from snowflake.ml.model import (
     _env as model_env,
     _model,
@@ -37,6 +39,7 @@ def _deploy_to_warehouse(
         **kwargs: Options that control some features in generated udf code.
 
     Raises:
+        ValueError: Raised when model file name is unable to encoded using ASCII.
         ValueError: Raised when incompatible model.
         ValueError: Raised when target method does not exist in model.
         ValueError: Raised when confronting invalid stage location.
@@ -44,14 +47,20 @@ def _deploy_to_warehouse(
     Returns:
         The metadata of the model deployed.
     """
+    # TODO(SNOW-862576): Should remove check on ASCII encoding after SNOW-862576 fixed.
     if model_dir_path:
         model_dir_path = os.path.normpath(model_dir_path)
         model_dir_name = os.path.basename(model_dir_path)
+        if not file_utils._able_ascii_encode(model_dir_name):
+            raise ValueError(f"Model file name {model_dir_name} cannot be encoded using ASCII. Please rename.")
         extract_model_code = infer_template._EXTRACT_LOCAL_MODEL_CODE.format(model_dir_name=model_dir_name)
         meta = _model.load_model(model_dir_path=model_dir_path, meta_only=True)
     else:
         assert model_stage_file_path is not None, "Unreachable assertion error."
-        model_stage_file_name = os.path.basename(model_stage_file_path)
+        model_stage_file_name = posixpath.basename(model_stage_file_path)
+        if not file_utils._able_ascii_encode(model_stage_file_name):
+            raise ValueError(f"Model file name {model_stage_file_name} cannot be encoded using ASCII. Please rename.")
+
         extract_model_code = infer_template._EXTRACT_STAGE_MODEL_CODE.format(
             model_stage_file_name=model_stage_file_name
         )
@@ -59,18 +68,22 @@ def _deploy_to_warehouse(
 
     relax_version = kwargs.get("relax_version", False)
 
+    disable_local_conda_resolver = kwargs.get("disable_local_conda_resolver", False)
+
     if target_method not in meta.signatures.keys():
         raise ValueError(f"Target method {target_method} does not exist in model.")
 
-    final_packages = _get_model_final_packages(meta, session, relax_version=relax_version)
+    final_packages = _get_model_final_packages(
+        meta, session, relax_version=relax_version, disable_local_conda_resolver=disable_local_conda_resolver
+    )
 
     stage_location = kwargs.get("permanent_udf_stage_location", None)
     if stage_location:
-        stage_location = stage_location.strip().rstrip("/")
+        stage_location = posixpath.normpath(stage_location.strip())
         if not stage_location.startswith("@"):
             raise ValueError(f"Invalid stage location {stage_location}.")
 
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False, encoding="utf-8") as f:
         _write_UDF_py_file(f.file, extract_model_code, target_method, **kwargs)
         print(f"Generated UDF file is persisted at: {f.name}")
         imports = ([model_dir_path] if model_dir_path else []) + (
@@ -89,7 +102,7 @@ def _deploy_to_warehouse(
         params = _UDFParams(
             file_path=f.name,
             func_name="infer",
-            name=f"{udf_name}",
+            name=identifier.get_inferred_name(udf_name),
             return_type=st.PandasSeriesType(st.MapType(st.StringType(), st.VariantType())),
             input_types=[st.PandasDataFrameType([st.MapType()])],
             imports=list(imports),
@@ -139,6 +152,7 @@ def _get_model_final_packages(
     meta: _model_meta.ModelMetadata,
     session: snowpark_session.Session,
     relax_version: Optional[bool] = False,
+    disable_local_conda_resolver: Optional[bool] = False,
 ) -> List[str]:
     """Generate final packages list of dependency of a model to be deployed to warehouse.
 
@@ -147,6 +161,8 @@ def _get_model_final_packages(
         session: Snowpark connection session.
         relax_version: Whether or not relax the version restriction when fail to resolve dependencies.
             Defaults to False.
+        disable_local_conda_resolver: Set to disable use local conda resolver to do pre-check on environment and rely on
+            the information schema only. Defaults to False.
 
     Raises:
         RuntimeError: Raised when PIP requirements and dependencies from non-Snowflake anaconda channel found.
@@ -165,6 +181,8 @@ def _get_model_final_packages(
     deps = meta._conda_dependencies[""]
 
     try:
+        if disable_local_conda_resolver:
+            raise ImportError("Raise to disable local conda resolver. Should be captured.")
         final_packages = env_utils.resolve_conda_environment(
             deps, [model_env._SNOWFLAKE_CONDA_CHANNEL_URL], python_version=meta.python_version
         )