snowflake-ml-python 1.8.5__py3-none-any.whl → 1.9.0__py3-none-any.whl

snowflake/ml/model/_client/model/model_version_impl.py

@@ -38,6 +38,96 @@ class ModelVersion(lineage_node.LineageNode):
     def __init__(self) -> None:
         raise RuntimeError("ModelVersion's initializer is not meant to be used. Use `version` from model instead.")
 
+    def _repr_html_(self) -> str:
+        """Generate an HTML representation of the model version.
+
+        Returns:
+            str: HTML string containing formatted model version details.
+        """
+        from snowflake.ml.utils import html_utils
+
+        # Get task
+        try:
+            task = self.get_model_task().value
+        except Exception:
+            task = (
+                html_utils.create_error_message("Not available")
+                .replace('<em style="color: #888; font-style: italic;">', "")
+                .replace("</em>", "")
+            )
+
+        # Get functions info for display
+        try:
+            functions = self.show_functions()
+            if not functions:
+                functions_html = html_utils.create_error_message("No functions available")
+            else:
+                functions_list = []
+                for func in functions:
+                    try:
+                        sig_html = func["signature"]._repr_html_()
+                    except Exception:
+                        # Fallback to simple display if can't display signature
+                        sig_html = f"<pre style='margin: 5px 0;'>{func['signature']}</pre>"
+
+                    function_content = f"""
+                        <div style="margin: 5px 0;">
+                            <strong>Target Method:</strong> {func['target_method']}
+                        </div>
+                        <div style="margin: 5px 0;">
+                            <strong>Function Type:</strong> {func.get('target_method_function_type', 'N/A')}
+                        </div>
+                        <div style="margin: 5px 0;">
+                            <strong>Partitioned:</strong> {func.get('is_partitioned', False)}
+                        </div>
+                        <div style="margin: 10px 0;">
+                            <strong>Signature:</strong>
+                            {sig_html}
+                        </div>
+                    """
+
+                    functions_list.append(
+                        html_utils.create_collapsible_section(
+                            title=func["name"], content=function_content, open_by_default=False
+                        )
+                    )
+                functions_html = "".join(functions_list)
+        except Exception:
+            functions_html = html_utils.create_error_message("Error retrieving functions")
+
+        # Get metrics for display
+        try:
+            metrics = self.show_metrics()
+            if not metrics:
+                metrics_html = html_utils.create_error_message("No metrics available")
+            else:
+                metrics_html = ""
+                for metric_name, value in metrics.items():
+                    metrics_html += html_utils.create_metric_item(metric_name, value)
+        except Exception:
+            metrics_html = html_utils.create_error_message("Error retrieving metrics")
+
+        # Create main content sections
+        main_info = html_utils.create_grid_section(
+            [
+                ("Model Name", self.model_name),
+                ("Version", f'<strong style="color: #28a745;">{self.version_name}</strong>'),
+                ("Full Name", self.fully_qualified_model_name),
+                ("Description", self.description),
+                ("Task", task),
+            ]
+        )
+
+        functions_section = html_utils.create_section_header("Functions") + html_utils.create_content_section(
+            functions_html
+        )
+
+        metrics_section = html_utils.create_section_header("Metrics") + html_utils.create_content_section(metrics_html)
+
+        content = main_info + functions_section + metrics_section
+
+        return html_utils.create_base_container("Model Version Details", content)
+
     @classmethod
     def _ref(
         cls,

snowflake/ml/model/_client/ops/model_ops.py

@@ -643,14 +643,17 @@ class ModelOperator:
         # TODO(sdas): Figure out a better way to filter out MODEL_BUILD_ services server side.
         fully_qualified_service_names = [str(service) for service in json_array if "MODEL_BUILD_" not in service]
 
-        result = []
-
+        result: list[ServiceInfo] = []
         for fully_qualified_service_name in fully_qualified_service_names:
             ingress_url: Optional[str] = None
             db, schema, service_name = sql_identifier.parse_fully_qualified_name(fully_qualified_service_name)
-            service_status, _ = self._service_client.get_service_status(
+            statuses = self._service_client.get_service_container_statuses(
                 database_name=db, schema_name=schema, service_name=service_name, statement_params=statement_params
             )
+            if len(statuses) == 0:
+                return result
+
+            service_status = statuses[0].service_status
             for res_row in self._service_client.show_endpoints(
                 database_name=db, schema_name=schema, service_name=service_name, statement_params=statement_params
             ):
@@ -952,7 +955,7 @@ class ModelOperator:
             output_with_input_features = False
             df = model_signature._convert_and_validate_local_data(X, signature.inputs, strict=strict_input_validation)
             s_df = snowpark_handler.SnowparkDataFrameHandler.convert_from_df(
-                self._session, df, keep_order=keep_order, features=signature.inputs
+                self._session, df, keep_order=keep_order, features=signature.inputs, statement_params=statement_params
             )
         else:
             keep_order = False
@@ -966,9 +969,16 @@ class ModelOperator:
 
         # Compose input and output names
         input_args = []
+        quoted_identifiers_ignore_case = (
+            snowpark_handler.SnowparkDataFrameHandler._is_quoted_identifiers_ignore_case_enabled(
+                self._session, statement_params
+            )
+        )
+
         for input_feature in signature.inputs:
             col_name = identifier_rule.get_sql_identifier_from_feature(input_feature.name)
-
+            if quoted_identifiers_ignore_case:
+                col_name = sql_identifier.SqlIdentifier(input_feature.name.upper(), case_sensitive=True)
             input_args.append(col_name)
 
         returns = []
@@ -1048,7 +1058,9 @@ class ModelOperator:
 
         # Get final result
         if not isinstance(X, dataframe.DataFrame):
-            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(df_res, features=signature.outputs)
+            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(
+                df_res, features=signature.outputs, statement_params=statement_params
+            )
         else:
             return df_res
 

snowflake/ml/model/_client/ops/service_ops.py

@@ -325,13 +325,14 @@ class ServiceOperator:
                         )
                         continue
 
-                service_status, message = self._service_client.get_service_status(
+                statuses = self._service_client.get_service_container_statuses(
                     database_name=service_log_meta.service.database_name,
                     schema_name=service_log_meta.service.schema_name,
                     service_name=service_log_meta.service.service_name,
                     include_message=True,
                     statement_params=statement_params,
                 )
+                service_status = statuses[0].service_status
                 if (service_status != service_sql.ServiceStatus.RUNNING) or (
                     service_status != service_log_meta.service_status
                 ):
@@ -341,7 +342,19 @@ class ServiceOperator:
                         f"{service_log_meta.service.display_service_name} is "
                         f"{service_log_meta.service_status.value}."
                     )
-                    module_logger.info(f"Service message: {message}")
+                    for status in statuses:
+                        if status.instance_id is not None:
+                            instance_status, container_status = None, None
+                            if status.instance_status is not None:
+                                instance_status = status.instance_status.value
+                            if status.container_status is not None:
+                                container_status = status.container_status.value
+                            module_logger.info(
+                                f"Instance[{status.instance_id}]: "
+                                f"instance status: {instance_status}, "
+                                f"container status: {container_status}, "
+                                f"message: {status.message}"
+                            )
 
                 new_logs, new_offset = fetch_logs(
                     service_log_meta.service,
@@ -353,13 +366,14 @@ class ServiceOperator:
 
                 # check if model build service is done
                 if not service_log_meta.is_model_build_service_done:
-                    service_status, _ = self._service_client.get_service_status(
+                    statuses = self._service_client.get_service_container_statuses(
                         database_name=model_build_service.database_name,
                         schema_name=model_build_service.schema_name,
                         service_name=model_build_service.service_name,
                         include_message=False,
                         statement_params=statement_params,
                     )
+                    service_status = statuses[0].service_status
 
                     if service_status == service_sql.ServiceStatus.DONE:
                         set_service_log_metadata_to_model_inference(
@@ -436,13 +450,14 @@ class ServiceOperator:
                 service_sql.ServiceStatus.FAILED,
             ]
         try:
-            service_status, _ = self._service_client.get_service_status(
+            statuses = self._service_client.get_service_container_statuses(
                 database_name=database_name,
                 schema_name=schema_name,
                 service_name=service_name,
                 include_message=False,
                 statement_params=statement_params,
             )
+            service_status = statuses[0].service_status
             return any(service_status == status for status in service_status_list_if_exists)
         except exceptions.SnowparkSQLException:
             return False
@@ -503,7 +518,7 @@ class ServiceOperator:
             output_with_input_features = False
             df = model_signature._convert_and_validate_local_data(X, signature.inputs)
             s_df = snowpark_handler.SnowparkDataFrameHandler.convert_from_df(
-                self._session, df, keep_order=keep_order, features=signature.inputs
+                self._session, df, keep_order=keep_order, features=signature.inputs, statement_params=statement_params
             )
         else:
             keep_order = False
@@ -615,7 +630,9 @@ class ServiceOperator:
 
         # get final result
         if not isinstance(X, dataframe.DataFrame):
-            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(df_res, features=signature.outputs)
+            return snowpark_handler.SnowparkDataFrameHandler.convert_to_df(
+                df_res, features=signature.outputs, statement_params=statement_params
+            )
         else:
             return df_res
 

snowflake/ml/model/_client/service/model_deployment_spec_schema.py

@@ -2,6 +2,8 @@ from typing import Optional
 
 from pydantic import BaseModel
 
+BaseModel.model_config["protected_namespaces"] = ()
+
 
 class Model(BaseModel):
     name: str

snowflake/ml/model/_client/sql/service.py

@@ -1,4 +1,6 @@
+import dataclasses
 import enum
+import logging
 import textwrap
 from typing import Any, Optional, Union
 
@@ -13,26 +15,59 @@ from snowflake.ml.model._model_composer.model_method import constants
 from snowflake.snowpark import dataframe, functions as F, row, types as spt
 from snowflake.snowpark._internal import utils as snowpark_utils
 
+logger = logging.getLogger(__name__)
+
 
-# The enum comes from https://docs.snowflake.com/en/sql-reference/sql/show-service-containers-in-service#output
-# except UNKNOWN
 class ServiceStatus(enum.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
-    SUSPENDING = "SUSPENDING"  # the service is set to suspended but the resource set is still in deleting state
-    SUSPENDED = "SUSPENDED"  # the service is suspended and the resource set is deleted
-    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
-    INTERNAL_ERROR = "INTERNAL_ERROR"  # there was an internal service error.
+    PENDING = "PENDING"
     RUNNING = "RUNNING"
+    FAILED = "FAILED"
+    DONE = "DONE"
+    SUSPENDING = "SUSPENDING"
+    SUSPENDED = "SUSPENDED"
+    DELETING = "DELETING"
     DELETED = "DELETED"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+
+
+class InstanceStatus(enum.Enum):
+    PENDING = "PENDING"
+    READY = "READY"
+    FAILED = "FAILED"
+    TERMINATING = "TERMINATING"
+    SUCCEEDED = "SUCCEEDED"
+
+
+class ContainerStatus(enum.Enum):
+    PENDING = "PENDING"
+    READY = "READY"
+    DONE = "DONE"
+    FAILED = "FAILED"
+    UNKNOWN = "UNKNOWN"
+
+
+@dataclasses.dataclass
+class ServiceStatusInfo:
+    """
+    Class containing information about service container status.
+    Reference: https://docs.snowflake.com/en/sql-reference/sql/show-service-containers-in-service
+    """
+
+    service_status: ServiceStatus
+    instance_id: Optional[int] = None
+    instance_status: Optional[InstanceStatus] = None
+    container_status: Optional[ContainerStatus] = None
+    message: Optional[str] = None
 
 
 class ServiceSQLClient(_base._BaseSQLClient):
     MODEL_INFERENCE_SERVICE_ENDPOINT_NAME_COL_NAME = "name"
     MODEL_INFERENCE_SERVICE_ENDPOINT_INGRESS_URL_COL_NAME = "ingress_url"
     SERVICE_STATUS = "service_status"
+    INSTANCE_ID = "instance_id"
+    INSTANCE_STATUS = "instance_status"
+    CONTAINER_STATUS = "status"
+    MESSAGE = "message"
 
     def build_model_container(
         self,
@@ -81,6 +116,10 @@ class ServiceSQLClient(_base._BaseSQLClient):
     ) -> tuple[str, snowpark.AsyncJob]:
         assert model_deployment_spec_yaml_str or model_deployment_spec_file_rel_path
         if model_deployment_spec_yaml_str:
+            model_deployment_spec_yaml_str = snowpark_utils.escape_single_quotes(
+                model_deployment_spec_yaml_str
+            )  # type: ignore[no-untyped-call]
+            logger.info(f"Deploying model with spec={model_deployment_spec_yaml_str}")
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('{model_deployment_spec_yaml_str}')"
         else:
             sql_str = f"CALL SYSTEM$DEPLOY_MODEL('@{stage_path}/{model_deployment_spec_file_rel_path}')"
@@ -192,7 +231,7 @@ class ServiceSQLClient(_base._BaseSQLClient):
         )
         return str(rows[0][system_func])
 
-    def get_service_status(
+    def get_service_container_statuses(
         self,
         *,
         database_name: Optional[sql_identifier.SqlIdentifier],
@@ -200,18 +239,27 @@ class ServiceSQLClient(_base._BaseSQLClient):
         service_name: sql_identifier.SqlIdentifier,
         include_message: bool = False,
         statement_params: Optional[dict[str, Any]] = None,
-    ) -> tuple[ServiceStatus, Optional[str]]:
+    ) -> list[ServiceStatusInfo]:
         fully_qualified_object_name = self.fully_qualified_object_name(database_name, schema_name, service_name)
         query = f"SHOW SERVICE CONTAINERS IN SERVICE {fully_qualified_object_name}"
         rows = self._session.sql(query).collect(statement_params=statement_params)
-        if len(rows) == 0:
-            return ServiceStatus.UNKNOWN, None
-        row = rows[0]
-        service_status = row[ServiceSQLClient.SERVICE_STATUS]
-        message = row["message"] if include_message else None
-        if not isinstance(service_status, ServiceStatus):
-            return ServiceStatus.UNKNOWN, message
-        return ServiceStatus(service_status), message
+        statuses = []
+        for r in rows:
+            instance_status, container_status = None, None
+            if r[ServiceSQLClient.INSTANCE_STATUS] is not None:
+                instance_status = InstanceStatus(r[ServiceSQLClient.INSTANCE_STATUS])
+            if r[ServiceSQLClient.CONTAINER_STATUS] is not None:
+                container_status = ContainerStatus(r[ServiceSQLClient.CONTAINER_STATUS])
+            statuses.append(
+                ServiceStatusInfo(
+                    service_status=ServiceStatus(r[ServiceSQLClient.SERVICE_STATUS]),
+                    instance_id=r[ServiceSQLClient.INSTANCE_ID],
+                    instance_status=instance_status,
+                    container_status=container_status,
+                    message=r[ServiceSQLClient.MESSAGE] if include_message else None,
+                )
+            )
+        return statuses
 
     def drop_service(
         self,

snowflake/ml/model/_client/sql/stage.py

@@ -12,9 +12,12 @@ class StageSQLClient(_base._BaseSQLClient):
         schema_name: Optional[sql_identifier.SqlIdentifier],
         stage_name: sql_identifier.SqlIdentifier,
         statement_params: Optional[dict[str, Any]] = None,
-    ) -> None:
+    ) -> str:
+        fq_stage_name = self.fully_qualified_object_name(database_name, schema_name, stage_name)
         query_result_checker.SqlResultValidator(
             self._session,
-            f"CREATE SCOPED TEMPORARY STAGE {self.fully_qualified_object_name(database_name, schema_name, stage_name)}",
+            f"CREATE SCOPED TEMPORARY STAGE {fq_stage_name}",
             statement_params=statement_params,
         ).has_dimensions(expected_rows=1, expected_cols=1).validate()
+
+        return fq_stage_name

snowflake/ml/model/_model_composer/model_manifest/model_manifest.py

@@ -7,6 +7,7 @@ from typing import Optional, cast
 import yaml
 
 from snowflake.ml._internal import env_utils
+from snowflake.ml._internal.exceptions import error_codes, exceptions
 from snowflake.ml.data import data_source
 from snowflake.ml.model import type_hints
 from snowflake.ml.model._model_composer.model_manifest import model_manifest_schema
@@ -53,17 +54,44 @@ class ModelManifest:
         if options is None:
             options = {}
 
+        has_pip_requirements = len(model_meta.env.pip_requirements) > 0
+        only_spcs = (
+            target_platforms
+            and len(target_platforms) == 1
+            and target_platforms[0] == type_hints.TargetPlatform.SNOWPARK_CONTAINER_SERVICES
+        )
+
         if "relax_version" not in options:
-            warnings.warn(
-                (
-                    "`relax_version` is not set and therefore defaulted to True. Dependency version constraints relaxed"
-                    " from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility, "
-                    "reproducibility, etc., set `options={'relax_version': False}` when logging the model."
-                ),
-                category=UserWarning,
-                stacklevel=2,
-            )
-        relax_version = options.get("relax_version", True)
+            if has_pip_requirements or only_spcs:
+                logger.info(
+                    "Setting `relax_version=False` as this model will run in Snowpark Container Services "
+                    "or in Warehouse with a specified artifact_repository_map where exact version "
+                    " specifications will be honored."
+                )
+                relax_version = False
+            else:
+                warnings.warn(
+                    (
+                        "`relax_version` is not set and therefore defaulted to True. Dependency version constraints"
+                        " relaxed from ==x.y.z to >=x.y, <(x+1). To use specific dependency versions for compatibility,"
+                        " reproducibility, etc., set `options={'relax_version': False}` when logging the model."
+                    ),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+                relax_version = True
+            options["relax_version"] = relax_version
+        else:
+            relax_version = options.get("relax_version", True)
+            if relax_version and (has_pip_requirements or only_spcs):
+                raise exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_ARGUMENT,
+                    original_exception=ValueError(
+                        "Setting `relax_version=True` is only allowed for models to be run in Warehouse with "
+                        "Snowflake Conda Channel dependencies. It cannot be used with pip requirements or when "
+                        "targeting only Snowpark Container Services."
+                    ),
+                )
 
         runtime_to_use = model_runtime.ModelRuntime(
             name=self._DEFAULT_RUNTIME_NAME,

snowflake/ml/model/_packager/model_env/model_env.py

@@ -9,6 +9,7 @@ from packaging import requirements, version
 
 from snowflake.ml import version as snowml_version
 from snowflake.ml._internal import env as snowml_env, env_utils
+from snowflake.ml.model import type_hints as model_types
 from snowflake.ml.model._packager.model_meta import model_meta_schema
 
 # requirement: Full version requirement where name is conda package name.
@@ -30,6 +31,7 @@ class ModelEnv:
         conda_env_rel_path: Optional[str] = None,
         pip_requirements_rel_path: Optional[str] = None,
         prefer_pip: bool = False,
+        target_platforms: Optional[list[model_types.TargetPlatform]] = None,
     ) -> None:
         if conda_env_rel_path is None:
             conda_env_rel_path = os.path.join(_DEFAULT_ENV_DIR, _DEFAULT_CONDA_ENV_FILENAME)
@@ -45,6 +47,8 @@ class ModelEnv:
         self._python_version: version.Version = version.parse(snowml_env.PYTHON_VERSION)
         self._cuda_version: Optional[version.Version] = None
         self._snowpark_ml_version: version.Version = version.parse(snowml_version.VERSION)
+        self._target_platforms = target_platforms
+        self._warnings_shown: set[str] = set()
 
     @property
     def conda_dependencies(self) -> list[str]:
@@ -116,6 +120,17 @@ class ModelEnv:
         if snowpark_ml_version:
             self._snowpark_ml_version = version.parse(snowpark_ml_version)
 
+    @property
+    def targets_warehouse(self) -> bool:
+        """Returns True if warehouse is a target platform."""
+        return self._target_platforms is None or model_types.TargetPlatform.WAREHOUSE in self._target_platforms
+
+    def _warn_once(self, message: str, stacklevel: int = 2) -> None:
+        """Show warning only once per ModelEnv instance."""
+        if message not in self._warnings_shown:
+            warnings.warn(message, category=UserWarning, stacklevel=stacklevel)
+            self._warnings_shown.add(message)
+
     def include_if_absent(
         self,
         pkgs: list[ModelDependency],
@@ -130,14 +145,14 @@ class ModelEnv:
         """
         if (self.pip_requirements or self.prefer_pip) and not self.conda_dependencies and pkgs:
             pip_pkg_reqs: list[str] = []
-            warnings.warn(
-                (
-                    "Dependencies specified from pip requirements."
-                    " This may prevent model deploying to Snowflake Warehouse."
-                ),
-                category=UserWarning,
-                stacklevel=2,
-            )
+            if self.targets_warehouse:
+                self._warn_once(
+                    (
+                        "Dependencies specified from pip requirements."
+                        " This may prevent model deploying to Snowflake Warehouse."
+                    ),
+                    stacklevel=2,
+                )
             for conda_req_str, pip_name in pkgs:
                 _, conda_req = env_utils._validate_conda_dependency_string(conda_req_str)
                 pip_req = requirements.Requirement(f"{pip_name}{conda_req.specifier}")
@@ -162,16 +177,15 @@ class ModelEnv:
                 req_to_add.name = conda_req.name
             else:
                 req_to_add = conda_req
-            show_warning_message = conda_req_channel == env_utils.DEFAULT_CHANNEL_NAME
+            show_warning_message = conda_req_channel == env_utils.DEFAULT_CHANNEL_NAME and self.targets_warehouse
 
             if any(added_pip_req.name == pip_name for added_pip_req in self._pip_requirements):
                 if show_warning_message:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Basic dependency {req_to_add.name} specified from pip requirements."
                             " This may prevent model deploying to Snowflake Warehouse."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
                 continue
@@ -182,12 +196,11 @@ class ModelEnv:
                 pass
             except env_utils.DuplicateDependencyInMultipleChannelsError:
                 if show_warning_message:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Basic dependency {req_to_add.name} specified from non-Snowflake channel."
                             + " This may prevent model deploying to Snowflake Warehouse."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
 
@@ -272,22 +285,20 @@ class ModelEnv:
         )
 
         for channel, channel_dependencies in conda_dependencies_dict.items():
-            if channel != env_utils.DEFAULT_CHANNEL_NAME:
-                warnings.warn(
+            if channel != env_utils.DEFAULT_CHANNEL_NAME and self.targets_warehouse:
+                self._warn_once(
                     (
                         "Found dependencies specified in the conda file from non-Snowflake channel."
                         " This may prevent model deploying to Snowflake Warehouse."
                     ),
-                    category=UserWarning,
                     stacklevel=2,
                 )
-            if len(channel_dependencies) == 0 and channel not in self._conda_dependencies:
-                warnings.warn(
+            if len(channel_dependencies) == 0 and channel not in self._conda_dependencies and self.targets_warehouse:
+                self._warn_once(
                     (
                         f"Found additional conda channel {channel} specified in the conda file."
                         " This may prevent model deploying to Snowflake Warehouse."
                     ),
-                    category=UserWarning,
                     stacklevel=2,
                 )
                 self._conda_dependencies[channel] = []
@@ -298,22 +309,20 @@ class ModelEnv:
                 except env_utils.DuplicateDependencyError:
                     pass
                 except env_utils.DuplicateDependencyInMultipleChannelsError:
-                    warnings.warn(
+                    self._warn_once(
                         (
                             f"Dependency {channel_dependency.name} appeared in multiple channels as conda dependency."
                             " This may be unintentional."
                         ),
-                        category=UserWarning,
                         stacklevel=2,
                     )
 
-        if pip_requirements_list:
-            warnings.warn(
+        if pip_requirements_list and self.targets_warehouse:
+            self._warn_once(
                 (
                     "Found dependencies specified as pip requirements."
                     " This may prevent model deploying to Snowflake Warehouse."
                 ),
-                category=UserWarning,
                 stacklevel=2,
             )
             for pip_dependency in pip_requirements_list:
@@ -333,13 +342,12 @@ class ModelEnv:
     def load_from_pip_file(self, pip_requirements_path: pathlib.Path) -> None:
         pip_requirements_list = env_utils.load_requirements_file(pip_requirements_path)
 
-        if pip_requirements_list:
-            warnings.warn(
+        if pip_requirements_list and self.targets_warehouse:
+            self._warn_once(
                 (
                     "Found dependencies specified as pip requirements."
                     " This may prevent model deploying to Snowflake Warehouse."
                 ),
-                category=UserWarning,
                 stacklevel=2,
             )
             for pip_dependency in pip_requirements_list:

snowflake/ml/model/_packager/model_handlers/pytorch.py

@@ -167,7 +167,11 @@ class PyTorchHandler(_base.BaseModelHandler["torch.nn.Module"]):
         model_blob_metadata = model_blobs_metadata[name]
         model_blob_filename = model_blob_metadata.path
         with open(os.path.join(model_blob_path, model_blob_filename), "rb") as f:
-            m = torch.load(f, map_location="cuda" if kwargs.get("use_gpu", False) else "cpu")
+            m = torch.load(
+                f,
+                map_location="cuda" if kwargs.get("use_gpu", False) else "cpu",
+                weights_only=False,
+            )
         assert isinstance(m, torch.nn.Module)
 
         return m